frameworks_base-apk_library_dir
-------------------------------
+This branch is for frameworks/native. It changes all the Vulkan components to
+use the SDK 0.10 version of the API and extensions.
+
+
+frameworks_base-apk_library_dir
+-------------------------------
This branch is for $TOP/frameworks/base. It modifies the framework to
inform the Vulkan loader, during activity startup, where the
activity's native library directory. The loader will search this
--- /dev/null
+From 72fe8189a53dfd3a54dc22d33b3ffe67bab93090 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Thu, 19 Nov 2015 21:32:50 -0800
+Subject: [PATCH 01/30] vulkan: Update from version 0.172.2 to 0.174.0
+
+Change-Id: If89614476735e5fb83cbeb4cf473e32e6f0cc386
+---
+ vulkan/api/vulkan.api | 92 ++++++++++++++++----------------------
+ vulkan/include/vulkan/vulkan.h | 92 ++++++++++++++++++--------------------
+ vulkan/libvulkan/entry.cpp | 9 +---
+ vulkan/libvulkan/get_proc_addr.cpp | 17 +++----
+ vulkan/libvulkan/loader.h | 3 +-
+ vulkan/nulldrv/null_driver.cpp | 5 +--
+ vulkan/nulldrv/null_driver.h | 3 +-
+ vulkan/nulldrv/null_driver_gen.cpp | 3 +-
+ 8 files changed, 94 insertions(+), 130 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 7616740..7ab0e86 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,8 +27,8 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 170
+-define VERSION_PATCH 2
++define VERSION_MINOR 174
++define VERSION_PATCH 0
+
+ // API limits
+ define VK_MAX_PHYSICAL_DEVICE_NAME 256
+@@ -538,8 +538,8 @@ enum VkFormat {
+ /// Shader stage enumerant
+ enum VkShaderStage {
+ VK_SHADER_STAGE_VERTEX = 0x00000000,
+- VK_SHADER_STAGE_TESS_CONTROL = 0x00000001,
+- VK_SHADER_STAGE_TESS_EVALUATION = 0x00000002,
++ VK_SHADER_STAGE_TESSELLATION_CONTROL = 0x00000001,
++ VK_SHADER_STAGE_TESSELLATION_EVALUATION = 0x00000002,
+ VK_SHADER_STAGE_GEOMETRY = 0x00000003,
+ VK_SHADER_STAGE_FRAGMENT = 0x00000004,
+ VK_SHADER_STAGE_COMPUTE = 0x00000005,
+@@ -750,8 +750,8 @@ bitfield VkBufferCreateFlags {
+ /// Shader stage flags
+ bitfield VkShaderStageFlags {
+ VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
+- VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002,
+- VK_SHADER_STAGE_TESS_EVALUATION_BIT = 0x00000004,
++ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
++ VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
+ VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
+ VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
+ VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
+@@ -867,17 +867,17 @@ bitfield VkCmdBufferOptimizeFlags {
+
+ /// Pipeline statistics flags
+ bitfield VkQueryPipelineStatisticFlags {
+- VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001, /// Optional
+- VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002, /// Optional
+- VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004, /// Optional
+- VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008, /// Optional
+- VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010, /// Optional
+- VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020, /// Optional
+- VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040, /// Optional
+- VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080, /// Optional
+- VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100, /// Optional
+- VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200, /// Optional
+- VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400, /// Optional
++ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, /// Optional
++ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, /// Optional
++ VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, /// Optional
++ VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, /// Optional
++ VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, /// Optional
++ VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, /// Optional
++ VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, /// Optional
++ VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, /// Optional
++ VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, /// Optional
++ VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, /// Optional
++ VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, /// Optional
+ }
+
+ /// Memory mapping flags
+@@ -910,8 +910,8 @@ bitfield VkPipelineStageFlags {
+ VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, /// Draw/DispatchIndirect command fetch
+ VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, /// Vertex/index fetch
+ VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, /// Vertex shading
+- VK_PIPELINE_STAGE_TESS_CONTROL_SHADER_BIT = 0x00000010, /// Tessellation control shading
+- VK_PIPELINE_STAGE_TESS_EVALUATION_SHADER_BIT = 0x00000020, /// Tessellation evaluation shading
++ VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, /// Tessellation control shading
++ VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, /// Tessellation evaluation shading
+ VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, /// Geometry shading
+ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, /// Fragment shading
+ VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, /// Early fragment (depth/stencil) tests
+@@ -1085,7 +1085,7 @@ class VkDeviceQueueCreateInfo {
+ class VkDeviceCreateInfo {
+ VkStructureType sType /// Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- u32 queueRecordCount
++ u32 requestedQueueRecordCount
+ const VkDeviceQueueCreateInfo* pRequestedQueues
+ u32 layerCount
+ const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled
+@@ -1503,7 +1503,7 @@ class VkPipelineViewportStateCreateInfo {
+ class VkPipelineRasterStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- VkBool32 depthClipEnable
++ VkBool32 depthClampEnable
+ VkBool32 rasterizerDiscardEnable
+ VkFillMode fillMode /// optional (GL45)
+ VkCullMode cullMode
+@@ -1696,6 +1696,12 @@ class VkClearValue {
+ VkClearDepthStencilValue depthStencil
+ }
+
++class VkClearAttachment {
++ VkImageAspectFlags aspectMask
++ u32 colorAttachment
++ VkClearValue clearValue
++}
++
+ class VkAttachmentDescription {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION
+ const void* pNext /// Pointer to next structure
+@@ -1776,7 +1782,7 @@ class VkPhysicalDeviceFeatures {
+ VkBool32 dualSourceBlend /// blend operations which take two sources
+ VkBool32 logicOp /// logic operations
+ VkBool32 multiDrawIndirect /// multi draw indirect
+- VkBool32 depthClip /// depth clipping
++ VkBool32 depthClamp /// depth clamping
+ VkBool32 depthBiasClamp /// depth bias clamping
+ VkBool32 fillModeNonSolid /// point and wireframe fill modes
+ VkBool32 depthBounds /// depth bounds test
+@@ -1857,14 +1863,14 @@ class VkPhysicalDeviceLimits {
+ u32 maxVertexInputBindingStride /// max vertex input binding stride
+ u32 maxVertexOutputComponents /// max num of output components written by vertex shader
+ /// tessellation control stage limits
+- u32 maxTessGenLevel /// max level supported by tess primitive generator
+- u32 maxTessPatchSize /// max patch size (vertices)
+- u32 maxTessControlPerVertexInputComponents /// max num of input components per-vertex in TCS
+- u32 maxTessControlPerVertexOutputComponents /// max num of output components per-vertex in TCS
+- u32 maxTessControlPerPatchOutputComponents /// max num of output components per-patch in TCS
+- u32 maxTessControlTotalOutputComponents /// max total num of per-vertex and per-patch output components in TCS
+- u32 maxTessEvaluationInputComponents /// max num of input components per vertex in TES
+- u32 maxTessEvaluationOutputComponents /// max num of output components per vertex in TES
++ u32 maxTessellationGenLevel /// max level supported by tess primitive generator
++ u32 maxTessellationPatchSize /// max patch size (vertices)
++ u32 maxTessellationControlPerVertexInputComponents /// max num of input components per-vertex in TCS
++ u32 maxTessellationControlPerVertexOutputComponents /// max num of output components per-vertex in TCS
++ u32 maxTessellationControlPerPatchOutputComponents /// max num of output components per-patch in TCS
++ u32 maxTessellationControlTotalOutputComponents /// max total num of per-vertex and per-patch output components in TCS
++ u32 maxTessellationEvaluationInputComponents /// max num of input components per vertex in TES
++ u32 maxTessellationEvaluationOutputComponents /// max num of output components per vertex in TES
+ /// geometry stage limits
+ u32 maxGeometryShaderInvocations /// max invocation count supported in geometry shader
+ u32 maxGeometryInputComponents /// max num of input components read in geometry stage
+@@ -4063,30 +4069,10 @@ cmd void vkCmdClearDepthStencilImage(
+ }
+
+ @threadSafety("app")
+-cmd void vkCmdClearColorAttachment(
+- VkCmdBuffer cmdBuffer,
+- u32 colorAttachment,
+- VkImageLayout imageLayout,
+- const VkClearColorValue* pColor,
+- u32 rectCount,
+- const VkRect3D* pRects) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+-
+- rects := pRects[0:rectCount]
+- for i in (0 .. rectCount) {
+- rect := rects[i]
+- }
+-
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
+-}
+-
+-@threadSafety("app")
+-cmd void vkCmdClearDepthStencilAttachment(
++cmd void vkCmdClearAttachments(
+ VkCmdBuffer cmdBuffer,
+- VkImageAspectFlags aspectMask,
+- VkImageLayout imageLayout,
+- const VkClearDepthStencilValue* pDepthStencil,
++ u32 attachmentCount,
++ const VkClearAttachment* pAttachments,
+ u32 rectCount,
+ const VkRect3D* pRects) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 03bcefe..5d884cd 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 170, 2)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 174, 0)
+
+
+ #if defined(__cplusplus) && (_MSC_VER >= 1800 || __cplusplus >= 201103L)
+@@ -511,8 +511,8 @@ typedef enum {
+
+ typedef enum {
+ VK_SHADER_STAGE_VERTEX = 0,
+- VK_SHADER_STAGE_TESS_CONTROL = 1,
+- VK_SHADER_STAGE_TESS_EVALUATION = 2,
++ VK_SHADER_STAGE_TESSELLATION_CONTROL = 1,
++ VK_SHADER_STAGE_TESSELLATION_EVALUATION = 2,
+ VK_SHADER_STAGE_GEOMETRY = 3,
+ VK_SHADER_STAGE_FRAGMENT = 4,
+ VK_SHADER_STAGE_COMPUTE = 5,
+@@ -924,17 +924,17 @@ typedef VkFlags VkSemaphoreCreateFlags;
+ typedef VkFlags VkEventCreateFlags;
+
+ typedef enum {
+- VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001,
+- VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002,
+- VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004,
+- VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008,
+- VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010,
+- VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020,
+- VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040,
+- VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080,
+- VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100,
+- VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200,
+- VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400,
++ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
++ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
++ VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
++ VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
++ VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
++ VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
++ VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
++ VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
++ VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
++ VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
++ VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
+ } VkQueryPipelineStatisticFlagBits;
+ typedef VkFlags VkQueryPipelineStatisticFlags;
+
+@@ -1000,8 +1000,8 @@ typedef VkFlags VkPipelineCreateFlags;
+
+ typedef enum {
+ VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
+- VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002,
+- VK_SHADER_STAGE_TESS_EVALUATION_BIT = 0x00000004,
++ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
++ VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
+ VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
+ VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
+ VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
+@@ -1024,8 +1024,8 @@ typedef enum {
+ VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
+ VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
+ VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
+- VK_PIPELINE_STAGE_TESS_CONTROL_SHADER_BIT = 0x00000010,
+- VK_PIPELINE_STAGE_TESS_EVALUATION_SHADER_BIT = 0x00000020,
++ VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
++ VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
+ VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
+ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
+ VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
+@@ -1150,7 +1150,7 @@ typedef struct {
+ VkBool32 dualSourceBlend;
+ VkBool32 logicOp;
+ VkBool32 multiDrawIndirect;
+- VkBool32 depthClip;
++ VkBool32 depthClamp;
+ VkBool32 depthBiasClamp;
+ VkBool32 fillModeNonSolid;
+ VkBool32 depthBounds;
+@@ -1246,14 +1246,14 @@ typedef struct {
+ uint32_t maxVertexInputAttributeOffset;
+ uint32_t maxVertexInputBindingStride;
+ uint32_t maxVertexOutputComponents;
+- uint32_t maxTessGenLevel;
+- uint32_t maxTessPatchSize;
+- uint32_t maxTessControlPerVertexInputComponents;
+- uint32_t maxTessControlPerVertexOutputComponents;
+- uint32_t maxTessControlPerPatchOutputComponents;
+- uint32_t maxTessControlTotalOutputComponents;
+- uint32_t maxTessEvaluationInputComponents;
+- uint32_t maxTessEvaluationOutputComponents;
++ uint32_t maxTessellationGenLevel;
++ uint32_t maxTessellationPatchSize;
++ uint32_t maxTessellationControlPerVertexInputComponents;
++ uint32_t maxTessellationControlPerVertexOutputComponents;
++ uint32_t maxTessellationControlPerPatchOutputComponents;
++ uint32_t maxTessellationControlTotalOutputComponents;
++ uint32_t maxTessellationEvaluationInputComponents;
++ uint32_t maxTessellationEvaluationOutputComponents;
+ uint32_t maxGeometryShaderInvocations;
+ uint32_t maxGeometryInputComponents;
+ uint32_t maxGeometryOutputComponents;
+@@ -1366,7 +1366,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- uint32_t queueRecordCount;
++ uint32_t requestedQueueCount;
+ const VkDeviceQueueCreateInfo* pRequestedQueues;
+ uint32_t layerCount;
+ const char*const* ppEnabledLayerNames;
+@@ -1665,7 +1665,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkBool32 depthClipEnable;
++ VkBool32 depthClampEnable;
+ VkBool32 rasterizerDiscardEnable;
+ VkFillMode fillMode;
+ VkCullMode cullMode;
+@@ -2013,6 +2013,17 @@ typedef struct {
+ uint32_t stencil;
+ } VkClearDepthStencilValue;
+
++typedef union {
++ VkClearColorValue color;
++ VkClearDepthStencilValue depthStencil;
++} VkClearValue;
++
++typedef struct {
++ VkImageAspectFlags aspectMask;
++ uint32_t colorAttachment;
++ VkClearValue clearValue;
++} VkClearAttachment;
++
+ typedef struct {
+ VkOffset3D offset;
+ VkExtent3D extent;
+@@ -2026,11 +2037,6 @@ typedef struct {
+ VkExtent3D extent;
+ } VkImageResolve;
+
+-typedef union {
+- VkClearColorValue color;
+- VkClearDepthStencilValue depthStencil;
+-} VkClearValue;
+-
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+@@ -2223,8 +2229,7 @@ typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer dest
+ typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
+ typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+ typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-typedef void (VKAPI *PFN_vkCmdClearColorAttachment)(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects);
+-typedef void (VKAPI *PFN_vkCmdClearDepthStencilAttachment)(VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rectCount, const VkRect3D* pRects);
++typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkRect3D* pRects);
+ typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+ typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+ typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+@@ -2916,19 +2921,10 @@ void VKAPI vkCmdClearDepthStencilImage(
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges);
+
+-void VKAPI vkCmdClearColorAttachment(
+- VkCmdBuffer cmdBuffer,
+- uint32_t colorAttachment,
+- VkImageLayout imageLayout,
+- const VkClearColorValue* pColor,
+- uint32_t rectCount,
+- const VkRect3D* pRects);
+-
+-void VKAPI vkCmdClearDepthStencilAttachment(
++void VKAPI vkCmdClearAttachments(
+ VkCmdBuffer cmdBuffer,
+- VkImageAspectFlags aspectMask,
+- VkImageLayout imageLayout,
+- const VkClearDepthStencilValue* pDepthStencil,
++ uint32_t attachmentCount,
++ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkRect3D* pRects);
+
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 2f7583d..4027f9a 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -682,13 +682,8 @@ void vkCmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLa
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdClearColorAttachment(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects) {
+- GetVtbl(cmdBuffer).CmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects);
+-}
+-
+-__attribute__((visibility("default")))
+-void vkCmdClearDepthStencilAttachment(VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rectCount, const VkRect3D* pRects) {
+- GetVtbl(cmdBuffer).CmdClearDepthStencilAttachment(cmdBuffer, aspectMask, imageLayout, pDepthStencil, rectCount, pRects);
++void vkCmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkRect3D* pRects) {
++ GetVtbl(cmdBuffer).CmdClearAttachments(cmdBuffer, attachmentCount, pAttachments, rectCount, pRects);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
+index 4f37c9c..bd16ac5 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp
++++ b/vulkan/libvulkan/get_proc_addr.cpp
+@@ -81,9 +81,8 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkCmdBindPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipeline)},
+ {"vkCmdBindVertexBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers)},
+ {"vkCmdBlitImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage)},
+- {"vkCmdClearColorAttachment", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearColorAttachment)},
++ {"vkCmdClearAttachments", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearAttachments)},
+ {"vkCmdClearColorImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearColorImage)},
+- {"vkCmdClearDepthStencilAttachment", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearDepthStencilAttachment)},
+ {"vkCmdClearDepthStencilImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearDepthStencilImage)},
+ {"vkCmdCopyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer)},
+ {"vkCmdCopyBufferToImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage)},
+@@ -242,9 +241,8 @@ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ {"vkCmdBindPipeline", offsetof(DeviceVtbl, CmdBindPipeline)},
+ {"vkCmdBindVertexBuffers", offsetof(DeviceVtbl, CmdBindVertexBuffers)},
+ {"vkCmdBlitImage", offsetof(DeviceVtbl, CmdBlitImage)},
+- {"vkCmdClearColorAttachment", offsetof(DeviceVtbl, CmdClearColorAttachment)},
++ {"vkCmdClearAttachments", offsetof(DeviceVtbl, CmdClearAttachments)},
+ {"vkCmdClearColorImage", offsetof(DeviceVtbl, CmdClearColorImage)},
+- {"vkCmdClearDepthStencilAttachment", offsetof(DeviceVtbl, CmdClearDepthStencilAttachment)},
+ {"vkCmdClearDepthStencilImage", offsetof(DeviceVtbl, CmdClearDepthStencilImage)},
+ {"vkCmdCopyBuffer", offsetof(DeviceVtbl, CmdCopyBuffer)},
+ {"vkCmdCopyBufferToImage", offsetof(DeviceVtbl, CmdCopyBufferToImage)},
+@@ -1063,14 +1061,9 @@ bool LoadDeviceVtbl(VkDevice device,
+ ALOGE("missing device proc: %s", "vkCmdClearDepthStencilImage");
+ success = false;
+ }
+- vtbl.CmdClearColorAttachment = reinterpret_cast<PFN_vkCmdClearColorAttachment>(get_proc_addr(device, "vkCmdClearColorAttachment"));
+- if (UNLIKELY(!vtbl.CmdClearColorAttachment)) {
+- ALOGE("missing device proc: %s", "vkCmdClearColorAttachment");
+- success = false;
+- }
+- vtbl.CmdClearDepthStencilAttachment = reinterpret_cast<PFN_vkCmdClearDepthStencilAttachment>(get_proc_addr(device, "vkCmdClearDepthStencilAttachment"));
+- if (UNLIKELY(!vtbl.CmdClearDepthStencilAttachment)) {
+- ALOGE("missing device proc: %s", "vkCmdClearDepthStencilAttachment");
++ vtbl.CmdClearAttachments = reinterpret_cast<PFN_vkCmdClearAttachments>(get_proc_addr(device, "vkCmdClearAttachments"));
++ if (UNLIKELY(!vtbl.CmdClearAttachments)) {
++ ALOGE("missing device proc: %s", "vkCmdClearAttachments");
+ success = false;
+ }
+ vtbl.CmdResolveImage = reinterpret_cast<PFN_vkCmdResolveImage>(get_proc_addr(device, "vkCmdResolveImage"));
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index 6999e1e..1ffbdd5 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -173,8 +173,7 @@ struct DeviceVtbl {
+ PFN_vkCmdFillBuffer CmdFillBuffer;
+ PFN_vkCmdClearColorImage CmdClearColorImage;
+ PFN_vkCmdClearDepthStencilImage CmdClearDepthStencilImage;
+- PFN_vkCmdClearColorAttachment CmdClearColorAttachment;
+- PFN_vkCmdClearDepthStencilAttachment CmdClearDepthStencilAttachment;
++ PFN_vkCmdClearAttachments CmdClearAttachments;
+ PFN_vkCmdResolveImage CmdResolveImage;
+ PFN_vkCmdSetEvent CmdSetEvent;
+ PFN_vkCmdResetEvent CmdResetEvent;
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 053e403..9d028eb 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -1019,10 +1019,7 @@ void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imag
+ void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ }
+
+-void CmdClearColorAttachment(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects) {
+-}
+-
+-void CmdClearDepthStencilAttachment(VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rectCount, const VkRect3D* pRects) {
++void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkRect3D* pRects) {
+ }
+
+ void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 808673a..4940148 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -154,8 +154,7 @@ void CmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize de
+ void CmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
+ void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+ void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-void CmdClearColorAttachment(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects);
+-void CmdClearDepthStencilAttachment(VkCmdBuffer cmdBuffer, VkImageAspectFlags aspectMask, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rectCount, const VkRect3D* pRects);
++void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkRect3D* pRects);
+ void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+ void CmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+ void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
+index ac6d50f..7f6ae8e 100644
+--- a/vulkan/nulldrv/null_driver_gen.cpp
++++ b/vulkan/nulldrv/null_driver_gen.cpp
+@@ -79,9 +79,8 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkCmdBindPipeline", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCmdBindPipeline>(CmdBindPipeline))},
+ {"vkCmdBindVertexBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCmdBindVertexBuffers>(CmdBindVertexBuffers))},
+ {"vkCmdBlitImage", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCmdBlitImage>(CmdBlitImage))},
+- {"vkCmdClearColorAttachment", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCmdClearColorAttachment>(CmdClearColorAttachment))},
++ {"vkCmdClearAttachments", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCmdClearAttachments>(CmdClearAttachments))},
+ {"vkCmdClearColorImage", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCmdClearColorImage>(CmdClearColorImage))},
+- {"vkCmdClearDepthStencilAttachment", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCmdClearDepthStencilAttachment>(CmdClearDepthStencilAttachment))},
+ {"vkCmdClearDepthStencilImage", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCmdClearDepthStencilImage>(CmdClearDepthStencilImage))},
+ {"vkCmdCopyBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCmdCopyBuffer>(CmdCopyBuffer))},
+ {"vkCmdCopyBufferToImage", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCmdCopyBufferToImage>(CmdCopyBufferToImage))},
+--
+2.4.0
+
--- /dev/null
+From 8ce9e519e5af3e2310765825115ffc3a65af818c Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Thu, 19 Nov 2015 21:51:33 -0800
+Subject: [PATCH 02/30] vulkan: Update from version 0.174.0 to 0.177.0
+
+Change-Id: I4b837c0bdb4fd6120688e8389ab8591178d370fb
+---
+ vulkan/api/templates/vulkan_h.tmpl | 2 +-
+ vulkan/api/vulkan.api | 12 +++++-------
+ vulkan/include/vulkan/vulkan.h | 25 ++++++++++---------------
+ vulkan/nulldrv/null_driver.cpp | 2 +-
+ vulkan/tools/vkinfo.cpp | 6 ++----
+ 5 files changed, 19 insertions(+), 28 deletions(-)
+
+diff --git a/vulkan/api/templates/vulkan_h.tmpl b/vulkan/api/templates/vulkan_h.tmpl
+index 2dee541..c55107d 100644
+--- a/vulkan/api/templates/vulkan_h.tmpl
++++ b/vulkan/api/templates/vulkan_h.tmpl
+@@ -53,7 +53,7 @@ extern "C" {
+ #define VK_API_VERSION \
+ VK_MAKE_VERSION({{Global "VERSION_MAJOR"}}, {{Global "VERSION_MINOR"}}, {{Global "VERSION_PATCH"}})
+ ¶
+-#if defined(__cplusplus) && (_MSC_VER >= 1800 || __cplusplus >= 201103L)
++#if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800 || __cplusplus >= 201103L)
+ #define VK_NULL_HANDLE nullptr
+ #else
+ #define VK_NULL_HANDLE 0
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 7ab0e86..2b499fd 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 174
++define VERSION_MINOR 177
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -695,8 +695,7 @@ bitfield VkMemoryPropertyFlags {
+ VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, /// Memory may not have i/o coherency so vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges must be used flush/invalidate host cache
+ /// vkInvalidateMappedMemoryRanges must be used flush/invalidate host cache
+ VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004, /// Memory should not be cached by the host
+- VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008, /// Memory should support host write combining
+- VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, /// Memory may be allocated by the driver when it is required
++ VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000008, /// Memory may be allocated by the driver when it is required
+ }
+
+ /// Memory heap flags
+@@ -932,7 +931,6 @@ bitfield VkAttachmentDescriptionFlags {
+
+ /// Subpass description flags
+ bitfield VkSubpassDescriptionFlags {
+- VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001,
+ }
+
+ /// Command pool creation flags
+@@ -1108,7 +1106,7 @@ class VkInstanceCreateInfo {
+ class VkQueueFamilyProperties {
+ VkQueueFlags queueFlags /// Queue flags
+ u32 queueCount
+- VkBool32 supportsTimestamps
++ u32 timestampValidBits
+ }
+
+ class VkPhysicalDeviceMemoryProperties {
+@@ -1522,6 +1520,8 @@ class VkPipelineMultisampleStateCreateInfo {
+ VkBool32 sampleShadingEnable /// optional (GL45)
+ f32 minSampleShading /// optional (GL45)
+ const VkSampleMask* pSampleMask
++ VkBool32 alphaToCoverageEnable
++ VkBool32 alphaToOneEnable
+ }
+
+ class VkPipelineColorBlendAttachmentState {
+@@ -1538,8 +1538,6 @@ class VkPipelineColorBlendAttachmentState {
+ class VkPipelineColorBlendStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- VkBool32 alphaToCoverageEnable
+- VkBool32 alphaToOneEnable
+ VkBool32 logicOpEnable
+ VkLogicOp logicOp
+ u32 attachmentCount /// # of pAttachments
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 5d884cd..124d088 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,10 +41,10 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 174, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 177, 0)
+
+
+-#if defined(__cplusplus) && (_MSC_VER >= 1800 || __cplusplus >= 201103L)
++#if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
+ #define VK_NULL_HANDLE nullptr
+ #else
+ #define VK_NULL_HANDLE 0
+@@ -711,10 +711,10 @@ typedef enum {
+ VK_TEX_ADDRESS_MODE_CLAMP = 2,
+ VK_TEX_ADDRESS_MODE_MIRROR_ONCE = 3,
+ VK_TEX_ADDRESS_MODE_CLAMP_BORDER = 4,
+- VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_MODE_WRAP,
+- VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_MODE_CLAMP_BORDER,
+- VK_TEX_ADDRESS_NUM = (VK_TEX_ADDRESS_MODE_CLAMP_BORDER - VK_TEX_ADDRESS_MODE_WRAP + 1),
+- VK_TEX_ADDRESS_MAX_ENUM = 0x7FFFFFFF
++ VK_TEX_ADDRESS_MODE_BEGIN_RANGE = VK_TEX_ADDRESS_MODE_WRAP,
++ VK_TEX_ADDRESS_MODE_END_RANGE = VK_TEX_ADDRESS_MODE_CLAMP_BORDER,
++ VK_TEX_ADDRESS_MODE_NUM = (VK_TEX_ADDRESS_MODE_CLAMP_BORDER - VK_TEX_ADDRESS_MODE_WRAP + 1),
++ VK_TEX_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkTexAddressMode;
+
+ typedef enum {
+@@ -893,8 +893,7 @@ typedef enum {
+ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001,
+ VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002,
+ VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004,
+- VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008,
+- VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
++ VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000008,
+ } VkMemoryPropertyFlagBits;
+ typedef VkFlags VkMemoryPropertyFlags;
+
+@@ -1013,10 +1012,6 @@ typedef enum {
+ VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
+ } VkAttachmentDescriptionFlagBits;
+ typedef VkFlags VkAttachmentDescriptionFlags;
+-
+-typedef enum {
+- VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001,
+-} VkSubpassDescriptionFlagBits;
+ typedef VkFlags VkSubpassDescriptionFlags;
+
+ typedef enum {
+@@ -1336,7 +1331,7 @@ typedef struct {
+ typedef struct {
+ VkQueueFlags queueFlags;
+ uint32_t queueCount;
+- VkBool32 supportsTimestamps;
++ uint32_t timestampValidBits;
+ } VkQueueFamilyProperties;
+
+ typedef struct {
+@@ -1684,6 +1679,8 @@ typedef struct {
+ VkBool32 sampleShadingEnable;
+ float minSampleShading;
+ const VkSampleMask* pSampleMask;
++ VkBool32 alphaToCoverageEnable;
++ VkBool32 alphaToOneEnable;
+ } VkPipelineMultisampleStateCreateInfo;
+
+ typedef struct {
+@@ -1724,8 +1721,6 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkBool32 alphaToCoverageEnable;
+- VkBool32 alphaToOneEnable;
+ VkBool32 logicOpEnable;
+ VkLogicOp logicOp;
+ uint32_t attachmentCount;
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 9d028eb..8992db4 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -288,7 +288,7 @@ VkResult GetPhysicalDeviceQueueFamilyProperties(
+ properties->queueFlags =
+ VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_DMA_BIT;
+ properties->queueCount = 1;
+- properties->supportsTimestamps = VK_FALSE;
++ properties->timestampValidBits = 64;
+ }
+ *count = 1;
+ return VK_SUCCESS;
+diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
+index 583e607..2af04ad 100644
+--- a/vulkan/tools/vkinfo.cpp
++++ b/vulkan/tools/vkinfo.cpp
+@@ -124,8 +124,6 @@ void DumpPhysicalDevice(uint32_t idx, VkPhysicalDevice pdev) {
+ strbuf << " NON_COHERENT";
+ if ((flags & VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT) != 0)
+ strbuf << " UNCACHED";
+- if ((flags & VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT) != 0)
+- strbuf << " WRITE_COMBINED";
+ if ((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
+ strbuf << " LAZILY_ALLOCATED";
+ printf(" Type %u: %s\n", type, strbuf.str().c_str());
+@@ -154,9 +152,9 @@ void DumpPhysicalDevice(uint32_t idx, VkPhysicalDevice pdev) {
+ queue_flags &= ~flag;
+ sep = "+";
+ }
+- printf(" Queue Family %u: %2ux %s timestamps:%s\n", family,
++ printf(" Queue Family %u: %2ux %s timestamps:%ub\n", family,
+ qprops.queueCount, strbuf.str().c_str(),
+- qprops.supportsTimestamps ? "YES" : "NO");
++ qprops.timestampValidBits);
+ strbuf.str(std::string());
+ }
+ }
+--
+2.4.0
+
--- /dev/null
+From 88b01c7acbc82f42d074c4484954388167f03add Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Thu, 19 Nov 2015 22:17:28 -0800
+Subject: [PATCH 03/30] vulkan: Update from version 0.177.0 to 0.179.0
+
+Change-Id: I4d596efec04a712d7b38323e012282fe9f98192b
+---
+ vulkan/api/vulkan.api | 61 +++++++++++-------------------------
+ vulkan/include/vulkan/vulkan.h | 64 ++++++++++++++++++++------------------
+ vulkan/libvulkan/entry.cpp | 60 +++++++++++++++++------------------
+ vulkan/libvulkan/loader.cpp | 62 ++++++++++++++++--------------------
+ vulkan/libvulkan/loader.h | 8 ++---
+ vulkan/libvulkan/swapchain.cpp | 3 +-
+ vulkan/nulldrv/null_driver.cpp | 56 ++++++++++++---------------------
+ vulkan/nulldrv/null_driver.h | 30 +++++++++---------
+ vulkan/nulldrv/null_driver_gen.cpp | 2 +-
+ vulkan/tools/vkinfo.cpp | 20 ++++--------
+ 10 files changed, 154 insertions(+), 212 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 2b499fd..7844f63 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 177
++define VERSION_MINOR 179
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -621,7 +621,8 @@ enum VkResult {
+ VK_ERROR_MEMORY_MAP_FAILED = 0xFFFFFFFB,
+ VK_ERROR_LAYER_NOT_PRESENT = 0xFFFFFFFA,
+ VK_ERROR_EXTENSION_NOT_PRESENT = 0xFFFFFFF9,
+- VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF8,
++ VK_ERROR_FEATURE_NOT_PRESENT = 0xFFFFFFF8,
++ VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF7,
+ }
+
+ enum VkDynamicState {
+@@ -2157,18 +2158,16 @@ cmd PFN_vkVoidFunction vkGetInstanceProcAddr(
+ return ?
+ }
+
+-cmd VkResult vkGetPhysicalDeviceProperties(
++cmd void vkGetPhysicalDeviceProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+
+ properties := ?
+ pProperties[0] = properties
+-
+- return ?
+ }
+
+-cmd VkResult vkGetPhysicalDeviceQueueFamilyProperties(
++cmd void vkGetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice physicalDevice,
+ u32* pCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties) {
+@@ -2187,32 +2186,27 @@ cmd VkResult vkGetPhysicalDeviceQueueFamilyProperties(
+ // count := ?
+ // pCount[0] = count
+ // }
+- return ?
+ }
+
+-cmd VkResult vkGetPhysicalDeviceMemoryProperties(
++cmd void vkGetPhysicalDeviceMemoryProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+
+ memoryProperties := ?
+ pMemoryProperties[0] = memoryProperties
+-
+- return ?
+ }
+
+-cmd VkResult vkGetPhysicalDeviceFeatures(
++cmd void vkGetPhysicalDeviceFeatures(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+
+ features := ?
+ pFeatures[0] = features
+-
+- return ?
+ }
+
+-cmd VkResult vkGetPhysicalDeviceFormatProperties(
++cmd void vkGetPhysicalDeviceFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties) {
+@@ -2220,11 +2214,9 @@ cmd VkResult vkGetPhysicalDeviceFormatProperties(
+
+ formatProperties := ?
+ pFormatProperties[0] = formatProperties
+-
+- return ?
+ }
+
+-cmd VkResult vkGetPhysicalDeviceImageFormatProperties(
++cmd void vkGetPhysicalDeviceImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+@@ -2236,8 +2228,6 @@ cmd VkResult vkGetPhysicalDeviceImageFormatProperties(
+
+ imageFormatProperties := ?
+ pImageFormatProperties[0] = imageFormatProperties
+-
+- return ?
+ }
+
+
+@@ -2340,7 +2330,7 @@ cmd VkResult vkEnumerateDeviceExtensionProperties(
+ // Queue functions
+
+ @threadSafety("system")
+-cmd VkResult vkGetDeviceQueue(
++cmd void vkGetDeviceQueue(
+ VkDevice device,
+ u32 queueFamilyIndex,
+ u32 queueIndex,
+@@ -2353,8 +2343,6 @@ cmd VkResult vkGetDeviceQueue(
+ if !(queue in State.Queues) {
+ State.Queues[queue] = new!QueueObject(device: device)
+ }
+-
+- return ?
+ }
+
+ @threadSafety("app")
+@@ -2499,7 +2487,7 @@ cmd VkResult vkInvalidateMappedMemoryRanges(
+
+ // Memory management API functions
+
+-cmd VkResult vkGetDeviceMemoryCommitment(
++cmd void vkGetDeviceMemoryCommitment(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes) {
+@@ -2512,19 +2500,15 @@ cmd VkResult vkGetDeviceMemoryCommitment(
+
+ committedMemoryInBytes := ?
+ pCommittedMemoryInBytes[0] = committedMemoryInBytes
+-
+- return ?
+ }
+
+-cmd VkResult vkGetBufferMemoryRequirements(
++cmd void vkGetBufferMemoryRequirements(
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements) {
+ deviceObject := GetDevice(device)
+ bufferObject := GetBuffer(buffer)
+ assert(bufferObject.device == device)
+-
+- return ?
+ }
+
+ cmd VkResult vkBindBufferMemory(
+@@ -2554,15 +2538,13 @@ cmd VkResult vkBindBufferMemory(
+ return ?
+ }
+
+-cmd VkResult vkGetImageMemoryRequirements(
++cmd void vkGetImageMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements) {
+ deviceObject := GetDevice(device)
+ imageObject := GetImage(image)
+ assert(imageObject.device == device)
+-
+- return ?
+ }
+
+ cmd VkResult vkBindImageMemory(
+@@ -2592,7 +2574,7 @@ cmd VkResult vkBindImageMemory(
+ return ?
+ }
+
+-cmd VkResult vkGetImageSparseMemoryRequirements(
++cmd void vkGetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ u32* pNumRequirements,
+@@ -2600,11 +2582,9 @@ cmd VkResult vkGetImageSparseMemoryRequirements(
+ deviceObject := GetDevice(device)
+ imageObject := GetImage(image)
+ assert(imageObject.device == device)
+-
+- return ?
+ }
+
+-cmd VkResult vkGetPhysicalDeviceSparseImageFormatProperties(
++cmd void vkGetPhysicalDeviceSparseImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+@@ -2614,8 +2594,6 @@ cmd VkResult vkGetPhysicalDeviceSparseImageFormatProperties(
+ u32* pNumProperties,
+ VkSparseImageFormatProperties* pProperties) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+-
+- return ?
+ }
+
+ cmd VkResult vkQueueBindSparseBufferMemory(
+@@ -2985,7 +2963,7 @@ cmd void vkDestroyImage(
+ State.Images[image] = null
+ }
+
+-cmd VkResult vkGetImageSubresourceLayout(
++cmd void vkGetImageSubresourceLayout(
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+@@ -2993,8 +2971,6 @@ cmd VkResult vkGetImageSubresourceLayout(
+ deviceObject := GetDevice(device)
+ imageObject := GetImage(image)
+ assert(imageObject.device == device)
+-
+- return ?
+ }
+
+
+@@ -3122,6 +3098,7 @@ cmd platform.size_t vkGetPipelineCacheSize(
+ cmd VkResult vkGetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
++ platform.size_t dataSize,
+ void* pData) {
+ deviceObject := GetDevice(device)
+ pipelineCacheObject := GetPipelineCache(pipelineCache)
+@@ -3458,7 +3435,7 @@ cmd void vkDestroyRenderPass(
+ State.RenderPasses[renderPass] = null
+ }
+
+-cmd VkResult vkGetRenderAreaGranularity(
++cmd void vkGetRenderAreaGranularity(
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity) {
+@@ -3467,8 +3444,6 @@ cmd VkResult vkGetRenderAreaGranularity(
+
+ granularity := ?
+ pGranularity[0] = granularity
+-
+- return ?
+ }
+
+ // Command pool functions
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 124d088..eb427f8 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 177, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 179, 0)
+
+
+ #if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
+@@ -152,7 +152,8 @@ typedef enum {
+ VK_ERROR_MEMORY_MAP_FAILED = -5,
+ VK_ERROR_LAYER_NOT_PRESENT = -6,
+ VK_ERROR_EXTENSION_NOT_PRESENT = -7,
+- VK_ERROR_INCOMPATIBLE_DRIVER = -8,
++ VK_ERROR_FEATURE_NOT_PRESENT = -8,
++ VK_ERROR_INCOMPATIBLE_DRIVER = -9,
+ VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER,
+ VK_RESULT_END_RANGE = VK_INCOMPLETE,
+ VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1),
+@@ -2099,12 +2100,12 @@ typedef struct {
+ typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
+ typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
+ typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
++typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
++typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
++typedef void (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
++typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
++typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
++typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+ typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
+ typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
+ typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
+@@ -2113,7 +2114,7 @@ typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char*
+ typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+ typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties);
+ typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
+-typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
++typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+ typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
+ typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
+ typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
+@@ -2123,13 +2124,13 @@ typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, V
+ typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
+ typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+ typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+-typedef VkResult (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
++typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+ typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
+ typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
+-typedef VkResult (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+-typedef VkResult (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+-typedef VkResult (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
++typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
++typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
++typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
++typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+ typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+ typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+ typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
+@@ -2156,7 +2157,7 @@ typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBuffer
+ typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView);
+ typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
+ typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image);
+-typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
++typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+ typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
+ typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView);
+ typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
+@@ -2166,7 +2167,7 @@ typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader);
+ typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
+ typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
+ typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache);
+-typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData);
++typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData);
+ typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+ typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+ typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+@@ -2187,7 +2188,7 @@ typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFrame
+ typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer);
+ typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
+ typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass);
+-typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
++typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+ typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
+ typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool);
+ typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
+@@ -2254,16 +2255,16 @@ VkResult VKAPI vkEnumeratePhysicalDevices(
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices);
+
+-VkResult VKAPI vkGetPhysicalDeviceFeatures(
++void VKAPI vkGetPhysicalDeviceFeatures(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures);
+
+-VkResult VKAPI vkGetPhysicalDeviceFormatProperties(
++void VKAPI vkGetPhysicalDeviceFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties);
+
+-VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
++void VKAPI vkGetPhysicalDeviceImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+@@ -2272,16 +2273,16 @@ VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties);
+
+-VkResult VKAPI vkGetPhysicalDeviceProperties(
++void VKAPI vkGetPhysicalDeviceProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties);
+
+-VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
++void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties);
+
+-VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
++void VKAPI vkGetPhysicalDeviceMemoryProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+
+@@ -2321,7 +2322,7 @@ VkResult VKAPI vkEnumerateDeviceLayerProperties(
+ uint32_t* pCount,
+ VkLayerProperties* pProperties);
+
+-VkResult VKAPI vkGetDeviceQueue(
++void VKAPI vkGetDeviceQueue(
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+@@ -2370,7 +2371,7 @@ VkResult VKAPI vkInvalidateMappedMemoryRanges(
+ uint32_t memRangeCount,
+ const VkMappedMemoryRange* pMemRanges);
+
+-VkResult VKAPI vkGetDeviceMemoryCommitment(
++void VKAPI vkGetDeviceMemoryCommitment(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes);
+@@ -2387,23 +2388,23 @@ VkResult VKAPI vkBindImageMemory(
+ VkDeviceMemory mem,
+ VkDeviceSize memOffset);
+
+-VkResult VKAPI vkGetBufferMemoryRequirements(
++void VKAPI vkGetBufferMemoryRequirements(
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements);
+
+-VkResult VKAPI vkGetImageMemoryRequirements(
++void VKAPI vkGetImageMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements);
+
+-VkResult VKAPI vkGetImageSparseMemoryRequirements(
++void VKAPI vkGetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ uint32_t* pNumRequirements,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+
+-VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
++void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+@@ -2539,7 +2540,7 @@ void VKAPI vkDestroyImage(
+ VkDevice device,
+ VkImage image);
+
+-VkResult VKAPI vkGetImageSubresourceLayout(
++void VKAPI vkGetImageSubresourceLayout(
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+@@ -2588,6 +2589,7 @@ size_t VKAPI vkGetPipelineCacheSize(
+ VkResult VKAPI vkGetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
++ size_t dataSize,
+ void* pData);
+
+ VkResult VKAPI vkMergePipelineCaches(
+@@ -2693,7 +2695,7 @@ void VKAPI vkDestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass);
+
+-VkResult VKAPI vkGetRenderAreaGranularity(
++void VKAPI vkGetRenderAreaGranularity(
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity);
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 4027f9a..b7c4848 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -67,33 +67,33 @@ PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName)
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
+- return GetVtbl(physicalDevice).GetPhysicalDeviceProperties(physicalDevice, pProperties);
++void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
++ GetVtbl(physicalDevice).GetPhysicalDeviceProperties(physicalDevice, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
+- return GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
++void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
++ GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
+- return GetVtbl(physicalDevice).GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
++void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
++ GetVtbl(physicalDevice).GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+- return GetVtbl(physicalDevice).GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
++void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
++ GetVtbl(physicalDevice).GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
+- return GetVtbl(physicalDevice).GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
++void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
++ GetVtbl(physicalDevice).GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+- return GetVtbl(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
++void vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
++ GetVtbl(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+ }
+
+ __attribute__((visibility("default")))
+@@ -127,8 +127,8 @@ VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, c
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
+- return vulkan::GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
++void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
++ vulkan::GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+ }
+
+ __attribute__((visibility("default")))
+@@ -177,13 +177,13 @@ VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount,
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
+- return GetVtbl(device).GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
++void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
++ GetVtbl(device).GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
+- return GetVtbl(device).GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
++void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
++ GetVtbl(device).GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+ }
+
+ __attribute__((visibility("default")))
+@@ -192,8 +192,8 @@ VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
+- return GetVtbl(device).GetImageMemoryRequirements(device, image, pMemoryRequirements);
++void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
++ GetVtbl(device).GetImageMemoryRequirements(device, image, pMemoryRequirements);
+ }
+
+ __attribute__((visibility("default")))
+@@ -202,13 +202,13 @@ VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, V
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+- return GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
++void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
++ GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
+- return GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
++void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
++ GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+@@ -342,8 +342,8 @@ void vkDestroyImage(VkDevice device, VkImage image) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+- return GetVtbl(device).GetImageSubresourceLayout(device, image, pSubresource, pLayout);
++void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
++ GetVtbl(device).GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+ }
+
+ __attribute__((visibility("default")))
+@@ -392,8 +392,8 @@ size_t vkGetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData) {
+- return GetVtbl(device).GetPipelineCacheData(device, pipelineCache, pData);
++VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData) {
++ return GetVtbl(device).GetPipelineCacheData(device, pipelineCache, dataSize, pData);
+ }
+
+ __attribute__((visibility("default")))
+@@ -497,8 +497,8 @@ void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+- return GetVtbl(device).GetRenderAreaGranularity(device, renderPass, pGranularity);
++void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
++ GetVtbl(device).GetRenderAreaGranularity(device, renderPass, pGranularity);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
+index fe33114..ba2f5cf 100644
+--- a/vulkan/libvulkan/loader.cpp
++++ b/vulkan/libvulkan/loader.cpp
+@@ -649,21 +649,19 @@ VkResult EnumeratePhysicalDevicesBottom(VkInstance instance,
+ return VK_SUCCESS;
+ }
+
+-VkResult GetPhysicalDeviceFeaturesBottom(VkPhysicalDevice pdev,
+- VkPhysicalDeviceFeatures* features) {
+- return GetVtbl(pdev)
+- ->instance->drv.vtbl.GetPhysicalDeviceFeatures(pdev, features);
++void GetPhysicalDeviceFeaturesBottom(VkPhysicalDevice pdev,
++ VkPhysicalDeviceFeatures* features) {
++ GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFeatures(pdev, features);
+ }
+
+-VkResult GetPhysicalDeviceFormatPropertiesBottom(
+- VkPhysicalDevice pdev,
+- VkFormat format,
+- VkFormatProperties* properties) {
+- return GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFormatProperties(
++void GetPhysicalDeviceFormatPropertiesBottom(VkPhysicalDevice pdev,
++ VkFormat format,
++ VkFormatProperties* properties) {
++ GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFormatProperties(
+ pdev, format, properties);
+ }
+
+-VkResult GetPhysicalDeviceImageFormatPropertiesBottom(
++void GetPhysicalDeviceImageFormatPropertiesBottom(
+ VkPhysicalDevice pdev,
+ VkFormat format,
+ VkImageType type,
+@@ -671,31 +669,28 @@ VkResult GetPhysicalDeviceImageFormatPropertiesBottom(
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* properties) {
+- return GetVtbl(pdev)
+- ->instance->drv.vtbl.GetPhysicalDeviceImageFormatProperties(
+- pdev, format, type, tiling, usage, flags, properties);
++ GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceImageFormatProperties(
++ pdev, format, type, tiling, usage, flags, properties);
+ }
+
+-VkResult GetPhysicalDevicePropertiesBottom(
+- VkPhysicalDevice pdev,
+- VkPhysicalDeviceProperties* properties) {
+- return GetVtbl(pdev)
++void GetPhysicalDevicePropertiesBottom(VkPhysicalDevice pdev,
++ VkPhysicalDeviceProperties* properties) {
++ GetVtbl(pdev)
+ ->instance->drv.vtbl.GetPhysicalDeviceProperties(pdev, properties);
+ }
+
+-VkResult GetPhysicalDeviceQueueFamilyPropertiesBottom(
++void GetPhysicalDeviceQueueFamilyPropertiesBottom(
+ VkPhysicalDevice pdev,
+ uint32_t* pCount,
+ VkQueueFamilyProperties* properties) {
+- return GetVtbl(pdev)
+- ->instance->drv.vtbl.GetPhysicalDeviceQueueFamilyProperties(
+- pdev, pCount, properties);
++ GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceQueueFamilyProperties(
++ pdev, pCount, properties);
+ }
+
+-VkResult GetPhysicalDeviceMemoryPropertiesBottom(
++void GetPhysicalDeviceMemoryPropertiesBottom(
+ VkPhysicalDevice pdev,
+ VkPhysicalDeviceMemoryProperties* properties) {
+- return GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceMemoryProperties(
++ GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceMemoryProperties(
+ pdev, properties);
+ }
+
+@@ -815,7 +810,7 @@ VkResult EnumerateDeviceLayerPropertiesBottom(VkPhysicalDevice pdev,
+ pdev, properties_count, properties);
+ }
+
+-VkResult GetPhysicalDeviceSparseImageFormatPropertiesBottom(
++void GetPhysicalDeviceSparseImageFormatPropertiesBottom(
+ VkPhysicalDevice pdev,
+ VkFormat format,
+ VkImageType type,
+@@ -824,7 +819,7 @@ VkResult GetPhysicalDeviceSparseImageFormatPropertiesBottom(
+ VkImageTiling tiling,
+ uint32_t* properties_count,
+ VkSparseImageFormatProperties* properties) {
+- return GetVtbl(pdev)
++ GetVtbl(pdev)
+ ->instance->drv.vtbl.GetPhysicalDeviceSparseImageFormatProperties(
+ pdev, format, type, samples, usage, tiling, properties_count,
+ properties);
+@@ -1061,25 +1056,20 @@ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* name) {
+ return GetSpecificDeviceProcAddr(GetVtbl(device), name);
+ }
+
+-VkResult GetDeviceQueue(VkDevice drv_device,
+- uint32_t family,
+- uint32_t index,
+- VkQueue* out_queue) {
++void GetDeviceQueue(VkDevice drv_device,
++ uint32_t family,
++ uint32_t index,
++ VkQueue* out_queue) {
+ VkResult result;
+ VkQueue queue;
+ const DeviceVtbl* vtbl = GetVtbl(drv_device);
+- result = vtbl->GetDeviceQueue(drv_device, family, index, &queue);
+- if (result != VK_SUCCESS)
+- return result;
++ vtbl->GetDeviceQueue(drv_device, family, index, &queue);
+ hwvulkan_dispatch_t* dispatch =
+ reinterpret_cast<hwvulkan_dispatch_t*>(queue);
+- if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC && dispatch->vtbl != vtbl) {
++ if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC && dispatch->vtbl != vtbl)
+ ALOGE("invalid VkQueue dispatch magic: 0x%" PRIxPTR, dispatch->magic);
+- return VK_ERROR_INITIALIZATION_FAILED;
+- }
+ dispatch->vtbl = vtbl;
+ *out_queue = queue;
+- return VK_SUCCESS;
+ }
+
+ VkResult CreateCommandBuffer(VkDevice drv_device,
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index 1ffbdd5..fcaec61 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -221,10 +221,10 @@ VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+ VkInstance* instance);
+ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name);
+ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice drv_device, const char* name);
+-VkResult GetDeviceQueue(VkDevice drv_device,
+- uint32_t family,
+- uint32_t index,
+- VkQueue* out_queue);
++void GetDeviceQueue(VkDevice drv_device,
++ uint32_t family,
++ uint32_t index,
++ VkQueue* out_queue);
+ VkResult CreateCommandBuffer(VkDevice device,
+ const VkCmdBufferCreateInfo* create_info,
+ VkCmdBuffer* out_cmdbuf);
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index 53c13a9..02d9515 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -311,8 +311,7 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ std::shared_ptr<ANativeWindow> window = InitSharedPtr(
+ device, static_cast<ANativeWindow*>(
+ reinterpret_cast<const VkSurfaceDescriptionWindowKHR*>(
+- create_info->pSurfaceDescription)
+- ->pPlatformWindow));
++ create_info->pSurfaceDescription)->pPlatformWindow));
+
+ // TODO(jessehall): Create and use NATIVE_WINDOW_API_VULKAN.
+ err = native_window_api_connect(window.get(), NATIVE_WINDOW_API_EGL);
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 8992db4..0d1b468 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -265,8 +265,8 @@ VkResult EnumeratePhysicalDevices(VkInstance instance,
+ return VK_SUCCESS;
+ }
+
+-VkResult GetPhysicalDeviceProperties(VkPhysicalDevice,
+- VkPhysicalDeviceProperties* properties) {
++void GetPhysicalDeviceProperties(VkPhysicalDevice,
++ VkPhysicalDeviceProperties* properties) {
+ properties->apiVersion = VK_API_VERSION;
+ properties->driverVersion = VK_MAKE_VERSION(0, 0, 1);
+ properties->vendorId = 0;
+@@ -275,26 +275,22 @@ VkResult GetPhysicalDeviceProperties(VkPhysicalDevice,
+ strcpy(properties->deviceName, "Android Vulkan Null Driver");
+ memset(properties->pipelineCacheUUID, 0,
+ sizeof(properties->pipelineCacheUUID));
+- return VK_SUCCESS;
+ }
+
+-VkResult GetPhysicalDeviceQueueFamilyProperties(
++void GetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice,
+ uint32_t* count,
+ VkQueueFamilyProperties* properties) {
+ if (properties) {
+- if (*count < 1)
+- return VK_INCOMPLETE;
+ properties->queueFlags =
+ VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_DMA_BIT;
+ properties->queueCount = 1;
+ properties->timestampValidBits = 64;
+ }
+ *count = 1;
+- return VK_SUCCESS;
+ }
+
+-VkResult GetPhysicalDeviceMemoryProperties(
++void GetPhysicalDeviceMemoryProperties(
+ VkPhysicalDevice,
+ VkPhysicalDeviceMemoryProperties* properties) {
+ properties->memoryTypeCount = 1;
+@@ -304,7 +300,6 @@ VkResult GetPhysicalDeviceMemoryProperties(
+ properties->memoryHeapCount = 1;
+ properties->memoryHeaps[0].size = kMaxDeviceMemory;
+ properties->memoryHeaps[0].flags = VK_MEMORY_HEAP_HOST_LOCAL_BIT;
+- return VK_SUCCESS;
+ }
+
+ // -----------------------------------------------------------------------------
+@@ -337,9 +332,8 @@ void DestroyDevice(VkDevice device) {
+ alloc->pfnFree(alloc->pUserData, device);
+ }
+
+-VkResult GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
++void GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
+ *queue = &device->queue;
+- return VK_SUCCESS;
+ }
+
+ // -----------------------------------------------------------------------------
+@@ -443,14 +437,13 @@ VkResult CreateBuffer(VkDevice device,
+ return VK_SUCCESS;
+ }
+
+-VkResult GetBufferMemoryRequirements(VkDevice,
+- VkBuffer buffer_handle,
+- VkMemoryRequirements* requirements) {
++void GetBufferMemoryRequirements(VkDevice,
++ VkBuffer buffer_handle,
++ VkMemoryRequirements* requirements) {
+ Buffer* buffer = GetObjectFromHandle(buffer_handle);
+ requirements->size = buffer->size;
+ requirements->alignment = 16; // allow fast Neon/SSE memcpy
+ requirements->memoryTypeBits = 0x1;
+- return VK_SUCCESS;
+ }
+
+ void DestroyBuffer(VkDevice device, VkBuffer buffer_handle) {
+@@ -502,14 +495,13 @@ VkResult CreateImage(VkDevice device,
+ return VK_SUCCESS;
+ }
+
+-VkResult GetImageMemoryRequirements(VkDevice,
+- VkImage image_handle,
+- VkMemoryRequirements* requirements) {
++void GetImageMemoryRequirements(VkDevice,
++ VkImage image_handle,
++ VkMemoryRequirements* requirements) {
+ Image* image = GetObjectFromHandle(image_handle);
+ requirements->size = image->size;
+ requirements->alignment = 16; // allow fast Neon/SSE memcpy
+ requirements->memoryTypeBits = 0x1;
+- return VK_SUCCESS;
+ }
+
+ void DestroyImage(VkDevice device, VkImage image_handle) {
+@@ -690,19 +682,16 @@ VkResult QueueSignalReleaseImageANDROID(VkQueue, VkImage, int* fence) {
+ #pragma clang diagnostic push
+ #pragma clang diagnostic ignored "-Wunused-parameter"
+
+-VkResult GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
++void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+ }
+
+-VkResult GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
++void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+ }
+
+-VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
++void GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+ }
+
+ VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
+@@ -747,9 +736,8 @@ VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, c
+ return VK_SUCCESS;
+ }
+
+-VkResult GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
++void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+ }
+
+ VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) {
+@@ -760,14 +748,12 @@ VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkD
+ return VK_SUCCESS;
+ }
+
+-VkResult GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
++void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+ }
+
+-VkResult GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
++void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+ }
+
+ VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
+@@ -842,9 +828,8 @@ VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t st
+ void DestroyBufferView(VkDevice device, VkBufferView bufferView) {
+ }
+
+-VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
++void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+ }
+
+ void DestroyImageView(VkDevice device, VkImageView imageView) {
+@@ -864,7 +849,7 @@ size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache) {
+ return VK_SUCCESS;
+ }
+
+-VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData) {
++VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ return VK_SUCCESS;
+ }
+@@ -909,9 +894,8 @@ void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer) {
+ void DestroyRenderPass(VkDevice device, VkRenderPass renderPass) {
+ }
+
+-VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
++void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+ }
+
+ void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool) {
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 4940148..2679777 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -29,12 +29,12 @@ PFN_vkVoidFunction LookupDeviceProcAddr(const char* name);
+ // clang-format off
+ void DestroyInstance(VkInstance instance);
+ VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+-VkResult GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+-VkResult GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+-VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+-VkResult GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+-VkResult GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+-VkResult GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
++void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
++void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
++void GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
++void GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
++void GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
++void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
+ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
+ VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
+@@ -43,7 +43,7 @@ VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t*
+ VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+ VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);
+ VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
+-VkResult GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
++void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+ VkResult QueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
+ VkResult QueueWaitIdle(VkQueue queue);
+ VkResult DeviceWaitIdle(VkDevice device);
+@@ -53,13 +53,13 @@ VkResult MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkD
+ void UnmapMemory(VkDevice device, VkDeviceMemory mem);
+ VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+ VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+-VkResult GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
++void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+ VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
+ VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
+-VkResult GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+-VkResult GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+-VkResult GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+-VkResult GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
++void GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
++void GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
++void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
++void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+ VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+ VkResult QueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+ VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
+@@ -86,7 +86,7 @@ VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreate
+ void DestroyBufferView(VkDevice device, VkBufferView bufferView);
+ VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
+ void DestroyImage(VkDevice device, VkImage image);
+-VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
++void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+ VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
+ void DestroyImageView(VkDevice device, VkImageView imageView);
+ VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
+@@ -96,7 +96,7 @@ void DestroyShader(VkDevice device, VkShader shader);
+ VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
+ void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache);
+ size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache);
+-VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData);
++VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData);
+ VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+ VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+ VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+@@ -117,7 +117,7 @@ VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCrea
+ void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer);
+ VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
+ void DestroyRenderPass(VkDevice device, VkRenderPass renderPass);
+-VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
++void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+ VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
+ void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool);
+ VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
+diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
+index 7f6ae8e..e86a795 100644
+--- a/vulkan/nulldrv/null_driver_gen.cpp
++++ b/vulkan/nulldrv/null_driver_gen.cpp
+@@ -31,7 +31,7 @@ struct NameProcEntry {
+ };
+
+ template <size_t N>
+-PFN_vkVoidFunction LookupProcAddr(const NameProcEntry (&table)[N],
++PFN_vkVoidFunction LookupProcAddr(const NameProcEntry(&table)[N],
+ const char* name) {
+ auto entry = std::lower_bound(table, table + N, name,
+ [](const NameProcEntry& e, const char* n) {
+diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
+index 2af04ad..50c3789 100644
+--- a/vulkan/tools/vkinfo.cpp
++++ b/vulkan/tools/vkinfo.cpp
+@@ -90,9 +90,7 @@ void DumpPhysicalDevice(uint32_t idx, VkPhysicalDevice pdev) {
+ std::ostringstream strbuf;
+
+ VkPhysicalDeviceProperties props;
+- result = vkGetPhysicalDeviceProperties(pdev, &props);
+- if (result != VK_SUCCESS)
+- die("vkGetPhysicalDeviceProperties", result);
++ vkGetPhysicalDeviceProperties(pdev, &props);
+ printf(" %u: \"%s\" (%s) %u.%u.%u/%#x [%04x:%04x]\n", idx,
+ props.deviceName, VkPhysicalDeviceTypeStr(props.deviceType),
+ (props.apiVersion >> 22) & 0x3FF, (props.apiVersion >> 12) & 0x3FF,
+@@ -100,9 +98,7 @@ void DumpPhysicalDevice(uint32_t idx, VkPhysicalDevice pdev) {
+ props.deviceId);
+
+ VkPhysicalDeviceMemoryProperties mem_props;
+- result = vkGetPhysicalDeviceMemoryProperties(pdev, &mem_props);
+- if (result != VK_SUCCESS)
+- die("vkGetPhysicalDeviceMemoryProperties", result);
++ vkGetPhysicalDeviceMemoryProperties(pdev, &mem_props);
+ for (uint32_t heap = 0; heap < mem_props.memoryHeapCount; heap++) {
+ if ((mem_props.memoryHeaps[heap].flags &
+ VK_MEMORY_HEAP_HOST_LOCAL_BIT) != 0)
+@@ -132,16 +128,12 @@ void DumpPhysicalDevice(uint32_t idx, VkPhysicalDevice pdev) {
+ }
+
+ uint32_t num_queue_families;
+- result = vkGetPhysicalDeviceQueueFamilyProperties(pdev, &num_queue_families,
+- nullptr);
+- if (result != VK_SUCCESS)
+- die("vkGetPhysicalDeviceQueueFamilyProperties (count)", result);
++ vkGetPhysicalDeviceQueueFamilyProperties(pdev, &num_queue_families,
++ nullptr);
+ std::vector<VkQueueFamilyProperties> queue_family_properties(
+ num_queue_families);
+- result = vkGetPhysicalDeviceQueueFamilyProperties(
+- pdev, &num_queue_families, queue_family_properties.data());
+- if (result != VK_SUCCESS)
+- die("vkGetPhysicalDeviceQueueFamilyProperties (values)", result);
++ vkGetPhysicalDeviceQueueFamilyProperties(pdev, &num_queue_families,
++ queue_family_properties.data());
+ for (uint32_t family = 0; family < num_queue_families; family++) {
+ const VkQueueFamilyProperties& qprops = queue_family_properties[family];
+ const char* sep = "";
+--
+2.4.0
+
--- /dev/null
+From 167ad20ec48e513fc70447a517d807f082bce6eb Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Thu, 19 Nov 2015 22:30:07 -0800
+Subject: [PATCH 04/30] vulkan: Update from version 0.179.0 to 0.180.0
+
+Change-Id: I2cbf4a8b065e8150734d76d614ab0850bc8324dc
+---
+ vulkan/api/vulkan.api | 33 +++++++++++++++++++++------------
+ vulkan/include/vulkan/vulkan.h | 19 ++++++++++++++-----
+ vulkan/libvulkan/entry.cpp | 4 ++--
+ vulkan/nulldrv/null_driver.cpp | 2 +-
+ vulkan/nulldrv/null_driver.h | 2 +-
+ 5 files changed, 39 insertions(+), 21 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 7844f63..669a64e 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 179
++define VERSION_MINOR 180
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -1058,6 +1058,15 @@ class VkLayerProperties {
+ char[VK_MAX_DESCRIPTION] description /// Free-form description of the layer
+ }
+
++class VkSubmitInfo {
++ u32 waitSemCount
++ const VkSemaphore* pWaitSemaphores
++ u32 cmdBufferCount
++ const VkCmdBuffer* pCommandBuffers
++ u32 signalSemCount
++ const VkSemaphore* pSignalSemaphores
++}
++
+ class VkApplicationInfo {
+ VkStructureType sType /// Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO
+ const void* pNext /// Next structure in chain
+@@ -2348,8 +2357,8 @@ cmd void vkGetDeviceQueue(
+ @threadSafety("app")
+ cmd VkResult vkQueueSubmit(
+ VkQueue queue,
+- u32 cmdBufferCount,
+- const VkCmdBuffer* pCmdBuffers,
++ u32 submitCount,
++ const VkSubmitInfo* pSubmitInfo,
+ VkFence fence) {
+ queueObject := GetQueue(queue)
+
+@@ -2358,15 +2367,15 @@ cmd VkResult vkQueueSubmit(
+ assert(fenceObject.device == queueObject.device)
+ }
+
+- cmdBuffers := pCmdBuffers[0:cmdBufferCount]
+- for i in (0 .. cmdBufferCount) {
+- cmdBuffer := cmdBuffers[i]
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- assert(cmdBufferObject.device == queueObject.device)
+-
+- validate("QueueCheck", cmdBufferObject.queueFlags in queueObject.flags,
+- "vkQueueSubmit: enqueued cmdBuffer requires missing queue capabilities.")
+- }
++ // cmdBuffers := pCmdBuffers[0:cmdBufferCount]
++ // for i in (0 .. cmdBufferCount) {
++ // cmdBuffer := cmdBuffers[i]
++ // cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ // assert(cmdBufferObject.device == queueObject.device)
++ //
++ // validate("QueueCheck", cmdBufferObject.queueFlags in queueObject.flags,
++ // "vkQueueSubmit: enqueued cmdBuffer requires missing queue capabilities.")
++ // }
+
+ return ?
+ }
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index eb427f8..3706b34 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 179, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 180, 0)
+
+
+ #if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
+@@ -97,12 +97,12 @@ VK_DEFINE_HANDLE(VkInstance)
+ VK_DEFINE_HANDLE(VkPhysicalDevice)
+ VK_DEFINE_HANDLE(VkDevice)
+ VK_DEFINE_HANDLE(VkQueue)
++VK_DEFINE_NONDISP_HANDLE(VkSemaphore)
+ VK_DEFINE_HANDLE(VkCmdBuffer)
+ VK_DEFINE_NONDISP_HANDLE(VkFence)
+ VK_DEFINE_NONDISP_HANDLE(VkDeviceMemory)
+ VK_DEFINE_NONDISP_HANDLE(VkBuffer)
+ VK_DEFINE_NONDISP_HANDLE(VkImage)
+-VK_DEFINE_NONDISP_HANDLE(VkSemaphore)
+ VK_DEFINE_NONDISP_HANDLE(VkEvent)
+ VK_DEFINE_NONDISP_HANDLE(VkQueryPool)
+ VK_DEFINE_NONDISP_HANDLE(VkBufferView)
+@@ -1384,6 +1384,15 @@ typedef struct {
+ } VkLayerProperties;
+
+ typedef struct {
++ uint32_t waitSemCount;
++ const VkSemaphore* pWaitSemaphores;
++ uint32_t cmdBufferCount;
++ const VkCmdBuffer* pCommandBuffers;
++ uint32_t signalSemCount;
++ const VkSemaphore* pSignalSemaphores;
++} VkSubmitInfo;
++
++typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceSize allocationSize;
+@@ -2115,7 +2124,7 @@ typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDev
+ typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties);
+ typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
+ typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+-typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
++typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
+ typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
+ typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
+ typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
+@@ -2330,8 +2339,8 @@ void VKAPI vkGetDeviceQueue(
+
+ VkResult VKAPI vkQueueSubmit(
+ VkQueue queue,
+- uint32_t cmdBufferCount,
+- const VkCmdBuffer* pCmdBuffers,
++ uint32_t submitCount,
++ const VkSubmitInfo* pSubmitInfo,
+ VkFence fence);
+
+ VkResult VKAPI vkQueueWaitIdle(
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index b7c4848..2bf6aae 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -132,8 +132,8 @@ void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queue
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) {
+- return GetVtbl(queue).QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
++VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence) {
++ return GetVtbl(queue).QueueSubmit(queue, submitCount, pSubmitInfo, fence);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 0d1b468..2bef297 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -709,7 +709,7 @@ VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, con
+ return VK_SUCCESS;
+ }
+
+-VkResult QueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) {
++VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence) {
+ return VK_SUCCESS;
+ }
+
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 2679777..a1d1e05 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -44,7 +44,7 @@ VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, con
+ VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);
+ VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
+ void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+-VkResult QueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
++VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
+ VkResult QueueWaitIdle(VkQueue queue);
+ VkResult DeviceWaitIdle(VkDevice device);
+ VkResult AllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
+--
+2.4.0
+
--- /dev/null
+From 5a0357fbe23928c47bb3e817bd3bb6635f2f1f08 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Thu, 19 Nov 2015 22:48:02 -0800
+Subject: [PATCH 05/30] vulkan: Update from version 0.180.0 to 0.181.0
+
+Change-Id: I4a7e216d9966f2dcf873bcb952472463dfb59f95
+---
+ vulkan/api/vulkan.api | 88 ++++++++++++---------------
+ vulkan/include/vulkan/vulkan.h | 132 +++++++++++++++++------------------------
+ vulkan/libvulkan/entry.cpp | 2 +-
+ vulkan/libvulkan/swapchain.cpp | 2 +-
+ vulkan/nulldrv/null_driver.cpp | 6 +-
+ vulkan/nulldrv/null_driver.h | 2 +-
+ vulkan/tools/vkinfo.cpp | 1 -
+ 7 files changed, 98 insertions(+), 135 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 669a64e..fbd1d9d 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 180
++define VERSION_MINOR 181
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -135,13 +135,6 @@ enum VkImageViewType {
+ VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 0x00000006,
+ }
+
+-enum VkImageAspect {
+- VK_IMAGE_ASPECT_COLOR = 0x00000000,
+- VK_IMAGE_ASPECT_DEPTH = 0x00000001,
+- VK_IMAGE_ASPECT_STENCIL = 0x00000002,
+- VK_IMAGE_ASPECT_METADATA = 0x00000003,
+-}
+-
+ enum VkCmdBufferLevel {
+ VK_CMD_BUFFER_LEVEL_PRIMARY = 0x00000000,
+ VK_CMD_BUFFER_LEVEL_SECONDARY = 0x00000001,
+@@ -535,16 +528,6 @@ enum VkFormat {
+ VK_FORMAT_B10G10R10A2_SINT = 0x000000AD,
+ }
+
+-/// Shader stage enumerant
+-enum VkShaderStage {
+- VK_SHADER_STAGE_VERTEX = 0x00000000,
+- VK_SHADER_STAGE_TESSELLATION_CONTROL = 0x00000001,
+- VK_SHADER_STAGE_TESSELLATION_EVALUATION = 0x00000002,
+- VK_SHADER_STAGE_GEOMETRY = 0x00000003,
+- VK_SHADER_STAGE_FRAGMENT = 0x00000004,
+- VK_SHADER_STAGE_COMPUTE = 0x00000005,
+-}
+-
+ /// Structure type enumerant
+ enum VkStructureType {
+ VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
+@@ -606,12 +589,11 @@ enum VkRenderPassContents {
+ enum VkResult {
+ // Return codes for successful operation execution (positive values)
+ VK_SUCCESS = 0x00000000,
+- VK_UNSUPPORTED = 0x00000001,
+- VK_NOT_READY = 0x00000002,
+- VK_TIMEOUT = 0x00000003,
+- VK_EVENT_SET = 0x00000004,
+- VK_EVENT_RESET = 0x00000005,
+- VK_INCOMPLETE = 0x00000006,
++ VK_NOT_READY = 0x00000001,
++ VK_TIMEOUT = 0x00000002,
++ VK_EVENT_SET = 0x00000003,
++ VK_EVENT_RESET = 0x00000004,
++ VK_INCOMPLETE = 0x00000005,
+
+ // Error codes (negative values)
+ VK_ERROR_OUT_OF_HOST_MEMORY = 0xFFFFFFFF,
+@@ -856,13 +838,11 @@ bitfield VkEventCreateFlags {
+ bitfield VkCmdBufferCreateFlags {
+ }
+
+-/// Command buffer optimization flags
+-bitfield VkCmdBufferOptimizeFlags {
+- VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001,
+- VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002,
+- VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004,
+- VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008,
+- VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010, /// Only one call to the secondary command buffer will exist at any given time
++/// Command buffer usage flags
++bitfield VkCmdBufferUsageFlags {
++ VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
++ VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
++ VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
+ }
+
+ /// Pipeline statistics flags
+@@ -1022,9 +1002,10 @@ class VkRect2D {
+ VkExtent2D extent
+ }
+
+-class VkRect3D {
+- VkOffset3D offset
+- VkExtent3D extent
++class VkClearRect {
++ VkRect2D rect
++ u32 baseArrayLayer
++ u32 numLayers
+ }
+
+ class VkChannelMapping {
+@@ -1140,7 +1121,7 @@ class VkMemoryRequirements {
+ }
+
+ class VkSparseImageFormatProperties {
+- VkImageAspect aspect
++ VkImageAspectFlags aspect
+ VkExtent3D imageGranularity
+ VkSparseImageFormatFlags flags
+ }
+@@ -1180,23 +1161,28 @@ class VkFormatProperties {
+ class VkImageFormatProperties {
+ VkExtent3D maxExtent /// max image dimensions for this resource type
+ u32 maxMipLevels /// max number of mipmap levels for this resource type
+- u32 maxArraySize /// max array size for this resource type
++ u32 maxArrayLayers /// max array layers for this resource type
+ VkSampleCountFlags sampleCounts /// supported sample counts for this resource type
+ VkDeviceSize maxResourceSize /// max size (in bytes) of this resource type
+ }
+
++class VkDescriptorImageInfo {
++ VkSampler sampler
++ VkImageView imageView
++ VkImageLayout imageLayout
++}
++
+ class VkDescriptorBufferInfo {
+ VkBuffer buffer /// Buffer used for this descriptor when the descriptor is UNIFORM_BUFFER[_DYNAMIC]
+ VkDeviceSize offset /// Base offset from buffer start in bytes to update in the descriptor set.
+ VkDeviceSize range /// Size in bytes of the buffer resource for this descriptor update.
+ }
+
++@union
+ class VkDescriptorInfo {
+- VkBufferView bufferView /// Buffer view to write to the descriptor (in case it's a buffer descriptor, otherwise should be VK_NULL_HANDLE)
+- VkSampler sampler /// Sampler to write to the descriptor (in case it's a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor, otherwise should be VK_NULL_HANDLE)
+- VkImageView imageView /// Image view to write to the descriptor (in case it's a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor, otherwise should be VK_NULL_HANDLE)
+- VkImageLayout imageLayout /// Layout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE)
++ VkDescriptorImageInfo imageInfo
+ VkDescriptorBufferInfo bufferInfo /// Raw buffer, size and offset for UNIFORM_BUFFER[_DYNAMIC] or STORAGE_BUFFER[_DYNAMIC] descriptor types. Ignored otherwise.
++ VkBufferView texelBufferView
+ }
+
+ class VkWriteDescriptorSet {
+@@ -1243,7 +1229,7 @@ class VkBufferViewCreateInfo {
+ }
+
+ class VkImageSubresource {
+- VkImageAspect aspect
++ VkImageAspectFlags aspect
+ u32 mipLevel
+ u32 arrayLayer
+ }
+@@ -1251,9 +1237,9 @@ class VkImageSubresource {
+ class VkImageSubresourceRange {
+ VkImageAspectFlags aspectMask
+ u32 baseMipLevel
+- u32 mipLevels
++ u32 numLevels
+ u32 baseArrayLayer
+- u32 arraySize
++ u32 numLayers
+ }
+
+ class VkMemoryBarrier {
+@@ -1295,7 +1281,7 @@ class VkImageCreateInfo {
+ VkFormat format
+ VkExtent3D extent
+ u32 mipLevels
+- u32 arraySize
++ u32 arrayLayers
+ u32 samples
+ VkImageTiling tiling
+ VkImageUsageFlags usage /// Image usage flags
+@@ -1348,10 +1334,10 @@ class VkSparseImageMemoryBindInfo {
+ }
+
+ class VkImageSubresourceCopy {
+- VkImageAspect aspect
++ VkImageAspectFlags aspect
+ u32 mipLevel
+- u32 arrayLayer
+- u32 arraySize
++ u32 baseArrayLayer
++ u32 numLayers
+ }
+
+ class VkImageCopy {
+@@ -1402,7 +1388,7 @@ class VkShaderCreateInfo {
+ VkShaderModule module /// Module containing entry point
+ const char* pName /// Null-terminated entry point name
+ VkShaderCreateFlags flags /// Reserved
+- VkShaderStage stage
++ VkShaderStageFlags stage
+ }
+
+ class VkDescriptorSetLayoutBinding {
+@@ -1449,7 +1435,7 @@ class VkSpecializationInfo {
+ class VkPipelineShaderStageCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- VkShaderStage stage
++ VkShaderStageFlags stage
+ VkShader shader
+ const VkSpecializationInfo* pSpecializationInfo
+ }
+@@ -1668,7 +1654,7 @@ class VkCmdBufferCreateInfo {
+ class VkCmdBufferBeginInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO
+ const void* pNext /// Pointer to next structure
+- VkCmdBufferOptimizeFlags flags /// Command buffer optimization flags
++ VkCmdBufferUsageFlags flags /// Command buffer usage flags
+ VkRenderPass renderPass /// Render pass for secondary command buffers
+ u32 subpass
+ VkFramebuffer framebuffer /// Framebuffer for secondary command buffers
+@@ -4056,7 +4042,7 @@ cmd void vkCmdClearAttachments(
+ u32 attachmentCount,
+ const VkClearAttachment* pAttachments,
+ u32 rectCount,
+- const VkRect3D* pRects) {
++ const VkClearRect* pRects) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+
+ rects := pRects[0:rectCount]
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 3706b34..475ebec 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 180, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 181, 0)
+
+
+ #if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
+@@ -139,12 +139,11 @@ VK_DEFINE_NONDISP_HANDLE(VkCmdPool)
+
+ typedef enum {
+ VK_SUCCESS = 0,
+- VK_UNSUPPORTED = 1,
+- VK_NOT_READY = 2,
+- VK_TIMEOUT = 3,
+- VK_EVENT_SET = 4,
+- VK_EVENT_RESET = 5,
+- VK_INCOMPLETE = 6,
++ VK_NOT_READY = 1,
++ VK_TIMEOUT = 2,
++ VK_EVENT_SET = 3,
++ VK_EVENT_RESET = 4,
++ VK_INCOMPLETE = 5,
+ VK_ERROR_OUT_OF_HOST_MEMORY = -1,
+ VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
+ VK_ERROR_INITIALIZATION_FAILED = -3,
+@@ -439,17 +438,6 @@ typedef enum {
+ } VkPhysicalDeviceType;
+
+ typedef enum {
+- VK_IMAGE_ASPECT_COLOR = 0,
+- VK_IMAGE_ASPECT_DEPTH = 1,
+- VK_IMAGE_ASPECT_STENCIL = 2,
+- VK_IMAGE_ASPECT_METADATA = 3,
+- VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR,
+- VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_METADATA,
+- VK_IMAGE_ASPECT_NUM = (VK_IMAGE_ASPECT_METADATA - VK_IMAGE_ASPECT_COLOR + 1),
+- VK_IMAGE_ASPECT_MAX_ENUM = 0x7FFFFFFF
+-} VkImageAspect;
+-
+-typedef enum {
+ VK_QUERY_TYPE_OCCLUSION = 0,
+ VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
+ VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
+@@ -511,19 +499,6 @@ typedef enum {
+ } VkChannelSwizzle;
+
+ typedef enum {
+- VK_SHADER_STAGE_VERTEX = 0,
+- VK_SHADER_STAGE_TESSELLATION_CONTROL = 1,
+- VK_SHADER_STAGE_TESSELLATION_EVALUATION = 2,
+- VK_SHADER_STAGE_GEOMETRY = 3,
+- VK_SHADER_STAGE_FRAGMENT = 4,
+- VK_SHADER_STAGE_COMPUTE = 5,
+- VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX,
+- VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE,
+- VK_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1),
+- VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF
+-} VkShaderStage;
+-
+-typedef enum {
+ VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0,
+ VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1,
+ VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX,
+@@ -905,6 +880,13 @@ typedef VkFlags VkMemoryHeapFlags;
+ typedef VkFlags VkMemoryMapFlags;
+
+ typedef enum {
++ VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
++ VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
++ VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
++ VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
++} VkImageAspectFlagBits;
++
++typedef enum {
+ VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001,
+ VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
+ VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004,
+@@ -966,13 +948,6 @@ typedef enum {
+ VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
+ } VkBufferCreateFlagBits;
+ typedef VkFlags VkBufferCreateFlags;
+-
+-typedef enum {
+- VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
+- VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
+- VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
+- VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
+-} VkImageAspectFlagBits;
+ typedef VkFlags VkImageAspectFlags;
+
+ typedef enum {
+@@ -984,6 +959,16 @@ typedef VkFlags VkShaderModuleCreateFlags;
+ typedef VkFlags VkShaderCreateFlags;
+
+ typedef enum {
++ VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
++ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
++ VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
++ VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
++ VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
++ VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
++ VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
++} VkShaderStageFlagBits;
++
++typedef enum {
+ VK_CHANNEL_R_BIT = 0x00000001,
+ VK_CHANNEL_G_BIT = 0x00000002,
+ VK_CHANNEL_B_BIT = 0x00000004,
+@@ -997,16 +982,6 @@ typedef enum {
+ VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
+ } VkPipelineCreateFlagBits;
+ typedef VkFlags VkPipelineCreateFlags;
+-
+-typedef enum {
+- VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
+- VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
+- VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
+- VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
+- VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
+- VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
+- VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+-} VkShaderStageFlagBits;
+ typedef VkFlags VkShaderStageFlags;
+
+ typedef enum {
+@@ -1071,13 +1046,11 @@ typedef VkFlags VkCmdPoolResetFlags;
+ typedef VkFlags VkCmdBufferCreateFlags;
+
+ typedef enum {
+- VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001,
+- VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002,
+- VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004,
+- VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008,
+- VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010,
+-} VkCmdBufferOptimizeFlagBits;
+-typedef VkFlags VkCmdBufferOptimizeFlags;
++ VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
++ VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
++ VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
++} VkCmdBufferUsageFlagBits;
++typedef VkFlags VkCmdBufferUsageFlags;
+
+ typedef enum {
+ VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+@@ -1204,7 +1177,7 @@ typedef struct {
+ typedef struct {
+ VkExtent3D maxExtent;
+ uint32_t maxMipLevels;
+- uint32_t maxArraySize;
++ uint32_t maxArrayLayers;
+ VkSampleCountFlags sampleCounts;
+ VkDeviceSize maxResourceSize;
+ } VkImageFormatProperties;
+@@ -1414,7 +1387,7 @@ typedef struct {
+ } VkMemoryRequirements;
+
+ typedef struct {
+- VkImageAspect aspect;
++ VkImageAspectFlagBits aspect;
+ VkExtent3D imageGranularity;
+ VkSparseImageFormatFlags flags;
+ } VkSparseImageFormatProperties;
+@@ -1436,7 +1409,7 @@ typedef struct {
+ } VkSparseMemoryBindInfo;
+
+ typedef struct {
+- VkImageAspect aspect;
++ VkImageAspectFlagBits aspect;
+ uint32_t mipLevel;
+ uint32_t arrayLayer;
+ } VkImageSubresource;
+@@ -1509,7 +1482,7 @@ typedef struct {
+ VkFormat format;
+ VkExtent3D extent;
+ uint32_t mipLevels;
+- uint32_t arraySize;
++ uint32_t arrayLayers;
+ uint32_t samples;
+ VkImageTiling tiling;
+ VkImageUsageFlags usage;
+@@ -1537,9 +1510,9 @@ typedef struct {
+ typedef struct {
+ VkImageAspectFlags aspectMask;
+ uint32_t baseMipLevel;
+- uint32_t mipLevels;
++ uint32_t numLevels;
+ uint32_t baseArrayLayer;
+- uint32_t arraySize;
++ uint32_t numLayers;
+ } VkImageSubresourceRange;
+
+ typedef struct {
+@@ -1567,7 +1540,7 @@ typedef struct {
+ VkShaderModule module;
+ const char* pName;
+ VkShaderCreateFlags flags;
+- VkShaderStage stage;
++ VkShaderStageFlagBits stage;
+ } VkShaderCreateInfo;
+
+ typedef struct {
+@@ -1594,7 +1567,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkShaderStage stage;
++ VkShaderStageFlagBits stage;
+ VkShader shader;
+ const VkSpecializationInfo* pSpecializationInfo;
+ } VkPipelineShaderStageCreateInfo;
+@@ -1840,17 +1813,21 @@ typedef struct {
+ } VkDescriptorPoolCreateInfo;
+
+ typedef struct {
++ VkSampler sampler;
++ VkImageView imageView;
++ VkImageLayout imageLayout;
++} VkDescriptorImageInfo;
++
++typedef struct {
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ VkDeviceSize range;
+ } VkDescriptorBufferInfo;
+
+-typedef struct {
+- VkBufferView bufferView;
+- VkSampler sampler;
+- VkImageView imageView;
+- VkImageLayout imageLayout;
++typedef union {
++ VkDescriptorImageInfo imageInfo;
+ VkDescriptorBufferInfo bufferInfo;
++ VkBufferView texelBufferView;
+ } VkDescriptorInfo;
+
+ typedef struct {
+@@ -1962,7 +1939,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkCmdBufferOptimizeFlags flags;
++ VkCmdBufferUsageFlags flags;
+ VkRenderPass renderPass;
+ uint32_t subpass;
+ VkFramebuffer framebuffer;
+@@ -1975,10 +1952,10 @@ typedef struct {
+ } VkBufferCopy;
+
+ typedef struct {
+- VkImageAspect aspect;
++ VkImageAspectFlags aspect;
+ uint32_t mipLevel;
+- uint32_t arrayLayer;
+- uint32_t arraySize;
++ uint32_t baseArrayLayer;
++ uint32_t numLayers;
+ } VkImageSubresourceCopy;
+
+ typedef struct {
+@@ -2030,9 +2007,10 @@ typedef struct {
+ } VkClearAttachment;
+
+ typedef struct {
+- VkOffset3D offset;
+- VkExtent3D extent;
+-} VkRect3D;
++ VkRect2D rect;
++ uint32_t baseArrayLayer;
++ uint32_t numLayers;
++} VkClearRect;
+
+ typedef struct {
+ VkImageSubresourceCopy srcSubresource;
+@@ -2234,7 +2212,7 @@ typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer dest
+ typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
+ typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+ typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkRect3D* pRects);
++typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+ typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+ typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+ typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+@@ -2932,7 +2910,7 @@ void VKAPI vkCmdClearAttachments(
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+- const VkRect3D* pRects);
++ const VkClearRect* pRects);
+
+ void VKAPI vkCmdResolveImage(
+ VkCmdBuffer cmdBuffer,
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 2bf6aae..da3837e 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -682,7 +682,7 @@ void vkCmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLa
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkRect3D* pRects) {
++void vkCmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+ GetVtbl(cmdBuffer).CmdClearAttachments(cmdBuffer, attachmentCount, pAttachments, rectCount, pRects);
+ }
+
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index 02d9515..70c0e33 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -421,7 +421,7 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ .format = VK_FORMAT_R8G8B8A8_UNORM, // TODO(jessehall)
+ .extent = {0, 0, 1},
+ .mipLevels = 1,
+- .arraySize = 1,
++ .arrayLayers = 1,
+ .samples = 1,
+ .tiling = VK_IMAGE_TILING_OPTIMAL,
+ .usage = create_info->imageUsageFlags,
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 2bef297..f07dfa7 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -473,12 +473,12 @@ VkResult CreateImage(VkDevice device,
+ ALOGE("CreateImage: not yet implemented: type=%d format=%d mips=%u",
+ create_info->imageType, create_info->format,
+ create_info->mipLevels);
+- return VK_UNSUPPORTED;
++ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+
+ VkDeviceSize size =
+ VkDeviceSize(create_info->extent.width * create_info->extent.height) *
+- create_info->arraySize * create_info->samples * 4u;
++ create_info->arrayLayers * create_info->samples * 4u;
+ ALOGW_IF(size > kMaxDeviceMemory,
+ "CreateImage: image size 0x%" PRIx64
+ " exceeds max device memory size 0x%" PRIx64,
+@@ -1003,7 +1003,7 @@ void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imag
+ void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ }
+
+-void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkRect3D* pRects) {
++void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+ }
+
+ void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index a1d1e05..655a414 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -154,7 +154,7 @@ void CmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize de
+ void CmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
+ void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+ void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkRect3D* pRects);
++void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+ void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+ void CmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+ void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
+index 50c3789..918df47 100644
+--- a/vulkan/tools/vkinfo.cpp
++++ b/vulkan/tools/vkinfo.cpp
+@@ -32,7 +32,6 @@ namespace {
+ switch (result) {
+ // clang-format off
+ case VK_SUCCESS: result_str = "VK_SUCCESS"; break;
+- case VK_UNSUPPORTED: result_str = "VK_UNSUPPORTED"; break;
+ case VK_NOT_READY: result_str = "VK_NOT_READY"; break;
+ case VK_TIMEOUT: result_str = "VK_TIMEOUT"; break;
+ case VK_EVENT_SET: result_str = "VK_EVENT_SET"; break;
+--
+2.4.0
+
--- /dev/null
+From 727d614d172fd03c033739b9a76873f9d46f8f5e Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Fri, 20 Nov 2015 14:17:03 -0800
+Subject: [PATCH 06/30] vulkan: Update from version 0.181.0 to 0.183.0
+
+Change-Id: I721bfc6891974e2bab7dce7e92e7884de360412a
+---
+ vulkan/api/vulkan.api | 129 ++++++++++++++++++++-----------------
+ vulkan/include/vulkan/vulkan.h | 105 ++++++++++++++----------------
+ vulkan/libvulkan/entry.cpp | 16 ++---
+ vulkan/libvulkan/get_proc_addr.cpp | 20 +++---
+ vulkan/libvulkan/loader.cpp | 31 ++++-----
+ vulkan/libvulkan/loader.h | 10 +--
+ vulkan/nulldrv/null_driver.cpp | 57 ++++++++++------
+ vulkan/nulldrv/null_driver.h | 8 +--
+ vulkan/nulldrv/null_driver_gen.cpp | 4 +-
+ 9 files changed, 199 insertions(+), 181 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index fbd1d9d..175e353 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 181
++define VERSION_MINOR 183
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -163,16 +163,6 @@ enum VkDescriptorType {
+ VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 0x0000000a,
+ }
+
+-enum VkDescriptorPoolUsage {
+- VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0x00000000,
+- VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 0x00000001,
+-}
+-
+-enum VkDescriptorSetUsage {
+- VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000,
+- VK_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001,
+-}
+-
+ enum VkQueryType {
+ VK_QUERY_TYPE_OCCLUSION = 0x00000000,
+ VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001, /// Optional
+@@ -539,7 +529,7 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 6,
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 7,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 8,
+- VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 9,
++ VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 9,
+ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
+ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 11,
+ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 12,
+@@ -577,6 +567,7 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 44,
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45,
+ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 47,
+ }
+
+ enum VkRenderPassContents {
+@@ -741,6 +732,15 @@ bitfield VkShaderStageFlags {
+ VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+ }
+
++/// Descriptor pool create flags
++bitfield VkDescriptorPoolCreateFlags {
++ VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
++}
++
++/// Descriptor pool reset flags
++bitfield VkDescriptorPoolResetFlags {
++}
++
+ /// Image usage flags
+ bitfield VkImageUsageFlags {
+ VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, /// Can be used as a source of transfer operations
+@@ -834,10 +834,6 @@ bitfield VkShaderCreateFlags {
+ bitfield VkEventCreateFlags {
+ }
+
+-/// Command buffer creation flags
+-bitfield VkCmdBufferCreateFlags {
+-}
+-
+ /// Command buffer usage flags
+ bitfield VkCmdBufferUsageFlags {
+ VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
+@@ -1069,6 +1065,7 @@ class VkDeviceQueueCreateInfo {
+ const void* pNext /// Pointer to next structure
+ u32 queueFamilyIndex
+ u32 queueCount
++ const f32* pQueuePriorities
+ }
+
+ class VkDeviceCreateInfo {
+@@ -1178,13 +1175,6 @@ class VkDescriptorBufferInfo {
+ VkDeviceSize range /// Size in bytes of the buffer resource for this descriptor update.
+ }
+
+-@union
+-class VkDescriptorInfo {
+- VkDescriptorImageInfo imageInfo
+- VkDescriptorBufferInfo bufferInfo /// Raw buffer, size and offset for UNIFORM_BUFFER[_DYNAMIC] or STORAGE_BUFFER[_DYNAMIC] descriptor types. Ignored otherwise.
+- VkBufferView texelBufferView
+-}
+-
+ class VkWriteDescriptorSet {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
+ const void* pNext /// Pointer to next structure
+@@ -1193,7 +1183,9 @@ class VkWriteDescriptorSet {
+ u32 destArrayElement /// Array element within the destination binding to write
+ u32 count /// Number of descriptors to write (determines the size of the array pointed by <pDescriptors>)
+ VkDescriptorType descriptorType /// Descriptor type to write (determines which fields of the array pointed by <pDescriptors> are going to be used)
+- const VkDescriptorInfo* pDescriptors /// Array of info structures describing the descriptors to write
++ const VkDescriptorImageInfo* pImageInfo
++ const VkDescriptorBufferInfo* pBufferInfo
++ const VkBufferView* pTexelBufferView
+ }
+
+ class VkCopyDescriptorSet {
+@@ -1413,12 +1405,20 @@ class VkDescriptorTypeCount {
+ class VkDescriptorPoolCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- VkDescriptorPoolUsage poolUsage
++ VkDescriptorPoolCreateFlags flags
+ u32 maxSets
+ u32 count
+ const VkDescriptorTypeCount* pTypeCount
+ }
+
++class VkDescriptorSetAllocInfo {
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO
++ const void* pNext /// Pointer to next structure
++ VkDescriptorPool descriptorPool
++ u32 count
++ const VkDescriptorSetLayout* pSetLayouts
++}
++
+ class VkSpecializationMapEntry {
+ u32 constantId /// The SpecConstant ID specified in the BIL
+ platform.size_t size /// Size in bytes of the SpecConstant
+@@ -1643,12 +1643,12 @@ class VkCmdPoolCreateInfo {
+ VkCmdPoolCreateFlags flags /// Command pool creation flags
+ }
+
+-class VkCmdBufferCreateInfo {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
++class VkCmdBufferAllocInfo {
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO
+ const void* pNext /// Pointer to next structure
+ VkCmdPool cmdPool
+ VkCmdBufferLevel level
+- VkCmdBufferCreateFlags flags /// Command buffer creation flags
++ u32 count
+ }
+
+ class VkCmdBufferBeginInfo {
+@@ -1782,6 +1782,9 @@ class VkPhysicalDeviceFeatures {
+ VkBool32 depthBounds /// depth bounds test
+ VkBool32 wideLines /// lines with width greater than 1
+ VkBool32 largePoints /// points with size greater than 1
++ VkBool32 alphaToOne /// The fragment alpha channel can be forced to maximum representable alpha value
++ VkBool32 multiViewport
++ VkBool32 samplerAnisotropy
+ VkBool32 textureCompressionETC2 /// ETC texture compression formats
+ VkBool32 textureCompressionASTC_LDR /// ASTC LDR texture compression formats
+ VkBool32 textureCompressionBC /// BC1-7 texture compressed formats
+@@ -1807,7 +1810,6 @@ class VkPhysicalDeviceFeatures {
+ VkBool32 shaderInt16 /// 16-bit integers in shaders
+ VkBool32 shaderResourceResidency /// shader can use texture operations that return resource residency information (requires sparseNonResident support)
+ VkBool32 shaderResourceMinLOD /// shader can use texture operations that specify minimum resource LOD
+- VkBool32 alphaToOne /// The fragment alpha channel can be forced to maximum representable alpha value
+ VkBool32 sparseBinding /// Sparse resources support: Resource memory can be managed at opaque page level rather than object level
+ VkBool32 sparseResidencyBuffer /// Sparse resources support: GPU can access partially resident buffers
+ VkBool32 sparseResidencyImage2D /// Sparse resources support: GPU can access partially resident 2D (non-MSAA non-DepthStencil) images
+@@ -1828,8 +1830,8 @@ class VkPhysicalDeviceLimits {
+ u32 maxImageArrayLayers /// max layers for image arrays
+ VkSampleCountFlags sampleCounts /// sample counts supported for all images supporting rendering and sampling
+ u32 maxTexelBufferSize /// max texel buffer size (bytes)
+- u32 maxUniformBufferSize /// max uniform buffer size (bytes)
+- u32 maxStorageBufferSize /// max storage buffer size (bytes)
++ u32 maxUniformBufferRange /// max uniform buffer size (bytes)
++ u32 maxStorageBufferRange /// max storage buffer size (bytes)
+ u32 maxPushConstantsSize /// max size of the push constants pool (bytes)
+ /// memory limits
+ u32 maxMemoryAllocationCount /// max number of device memory allocations supported
+@@ -1837,7 +1839,6 @@ class VkPhysicalDeviceLimits {
+ VkDeviceSize sparseAddressSpaceSize /// Total address space available for sparse allocations (bytes)
+ /// descriptor set limits
+ u32 maxBoundDescriptorSets /// max number of descriptors sets that can be bound to a pipeline
+- u32 maxDescriptorSets /// max number of allocated descriptor sets
+ u32 maxPerStageDescriptorSamplers /// max num of samplers allowed per-stage in a descriptor set
+ u32 maxPerStageDescriptorUniformBuffers /// max num of uniform buffers allowed per-stage in a descriptor set
+ u32 maxPerStageDescriptorStorageBuffers /// max num of storage buffers allowed per-stage in a descriptor set
+@@ -1873,8 +1874,8 @@ class VkPhysicalDeviceLimits {
+ u32 maxGeometryTotalOutputComponents /// max total num of components (all vertices) written in geometry stage
+ /// fragment stage limits
+ u32 maxFragmentInputComponents /// max num of input compontents read in fragment stage
+- u32 maxFragmentOutputBuffers /// max num of output buffers written in fragment stage
+- u32 maxFragmentDualSourceBuffers /// max num of output buffers written when using dual source blending
++ u32 maxFragmentOutputAttachments /// max num of output attachments written in fragment stage
++ u32 maxFragmentDualSourceAttachments /// max num of output attachments written when using dual source blending
+ u32 maxFragmentCombinedOutputResources /// max total num of storage buffers, storage images and output buffers
+ /// compute stage limits
+ u32 maxComputeSharedMemorySize /// max total storage size of work group local storage (bytes)
+@@ -1903,9 +1904,9 @@ class VkPhysicalDeviceLimits {
+ u32 minUniformBufferOffsetAlignment /// min required alignment for uniform buffer sizes and offsets (bytes)
+ u32 minStorageBufferOffsetAlignment /// min required alignment for storage buffer offsets (bytes)
+
+- u32 minTexelOffset /// min texel offset for OpTextureSampleOffset
++ s32 minTexelOffset /// min texel offset for OpTextureSampleOffset
+ u32 maxTexelOffset /// max texel offset for OpTextureSampleOffset
+- u32 minTexelGatherOffset /// min texel offset for OpTextureGatherOffset
++ s32 minTexelGatherOffset /// min texel offset for OpTextureGatherOffset
+ u32 maxTexelGatherOffset /// max texel offset for OpTextureGatherOffset
+ f32 minInterpolationOffset /// furthest negative offset for interpolateAtOffset
+ f32 maxInterpolationOffset /// furthest positive offset for interpolateAtOffset
+@@ -1931,6 +1932,8 @@ class VkPhysicalDeviceLimits {
+ u32 maxCullDistances /// max number of cull distances
+ u32 maxCombinedClipAndCullDistances /// max combined number of user clipping
+
++ u32 discreteQueuePriorities
++
+ f32[2] pointSizeRange /// range (min,max) of supported point sizes
+ f32[2] lineWidthRange /// range (min,max) of supported line widths
+ f32 pointSizeGranularity /// granularity of supported point sizes
+@@ -3294,7 +3297,8 @@ cmd void vkDestroyDescriptorPool(
+ @threadSafety("app")
+ cmd VkResult vkResetDescriptorPool(
+ VkDevice device,
+- VkDescriptorPool descriptorPool) {
++ VkDescriptorPool descriptorPool,
++ VkDescriptorPoolResetFlags flags) {
+ deviceObject := GetDevice(device)
+ descriptorPoolObject := GetDescriptorPool(descriptorPool)
+ assert(descriptorPoolObject.device == device)
+@@ -3305,23 +3309,21 @@ cmd VkResult vkResetDescriptorPool(
+ @threadSafety("app")
+ cmd VkResult vkAllocDescriptorSets(
+ VkDevice device,
+- VkDescriptorPool descriptorPool,
+- VkDescriptorSetUsage setUsage,
+- u32 count,
+- const VkDescriptorSetLayout* pSetLayouts,
++ const VkDescriptorSetAllocInfo* pAllocInfo,
+ VkDescriptorSet* pDescriptorSets) {
+ deviceObject := GetDevice(device)
+- descriptorPoolObject := GetDescriptorPool(descriptorPool)
++ allocInfo := pAllocInfo[0]
++ descriptorPoolObject := GetDescriptorPool(allocInfo.descriptorPool)
+
+- setLayouts := pSetLayouts[0:count]
+- for i in (0 .. count) {
++ setLayouts := allocInfo.pSetLayouts[0:allocInfo.count]
++ for i in (0 .. allocInfo.count) {
+ setLayout := setLayouts[i]
+ setLayoutObject := GetDescriptorSetLayout(setLayout)
+ assert(setLayoutObject.device == device)
+ }
+
+- descriptorSets := pDescriptorSets[0:count]
+- for i in (0 .. count) {
++ descriptorSets := pDescriptorSets[0:allocInfo.count]
++ for i in (0 .. allocInfo.count) {
+ descriptorSet := ?
+ descriptorSets[i] = descriptorSet
+ State.DescriptorSets[descriptorSet] = new!DescriptorSetObject(device: device)
+@@ -3497,29 +3499,38 @@ macro void unbindCmdBuffer(VkCmdBuffer cmdBuffer, any obj, VkDeviceMemory mem) {
+ }
+
+ @threadSafety("system")
+-cmd VkResult vkCreateCommandBuffer(
++cmd VkResult vkAllocCommandBuffers(
+ VkDevice device,
+- const VkCmdBufferCreateInfo* pCreateInfo,
+- VkCmdBuffer* pCmdBuffer) {
+- assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO)
++ const VkCmdBufferAllocInfo* pAllocInfo,
++ VkCmdBuffer* pCmdBuffers) {
++ assert(pAllocInfo[0].sType == VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO)
+
+- cmdBuffer := ?
+- pCmdBuffer[0] = cmdBuffer
+- State.CmdBuffers[cmdBuffer] = new!CmdBufferObject(device: device)
++ count := pAllocInfo[0].count
++ cmdBuffers := pCmdBuffers[0:count]
++ for i in (0 .. count) {
++ cmdBuffer := ?
++ cmdBuffers[i] = cmdBuffer
++ State.CmdBuffers[cmdBuffer] = new!CmdBufferObject(device: device)
++ }
+
+ return ?
+ }
+
+ @threadSafety("system")
+-cmd void vkDestroyCommandBuffer(
++cmd void vkFreeCommandBuffers(
+ VkDevice device,
+- VkCmdBuffer commandBuffer) {
++ VkCmdPool cmdPool,
++ u32 count,
++ const VkCmdBuffer* pCommandBuffers) {
+ deviceObject := GetDevice(device)
+- cmdBufferObject := GetCmdBuffer(commandBuffer)
+- assert(cmdBufferObject.device == device)
+
+- // TODO: iterate over boundObjects and clear memory bindings
+- State.CmdBuffers[commandBuffer] = null
++ cmdBuffers := pCommandBuffers[0:count]
++ for i in (0 .. count) {
++ cmdBufferObject := GetCmdBuffer(cmdBuffers[i])
++ assert(cmdBufferObject.device == device)
++ // TODO: iterate over boundObjects and clear memory bindings
++ State.CmdBuffers[cmdBuffers[i]] = null
++ }
+ }
+
+ @threadSafety("app")
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 475ebec..d6eb918 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 181, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 183, 0)
+
+
+ #if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
+@@ -169,7 +169,7 @@ typedef enum {
+ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 6,
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 7,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 8,
+- VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 9,
++ VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 9,
+ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
+ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 11,
+ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 12,
+@@ -207,9 +207,10 @@ typedef enum {
+ VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 44,
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45,
+ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 47,
+ VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+- VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
+- VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
++ VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO,
++ VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+ VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkStructureType;
+
+@@ -725,24 +726,6 @@ typedef enum {
+ } VkDescriptorType;
+
+ typedef enum {
+- VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0,
+- VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1,
+- VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT,
+- VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC,
+- VK_DESCRIPTOR_POOL_USAGE_NUM = (VK_DESCRIPTOR_POOL_USAGE_DYNAMIC - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT + 1),
+- VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF
+-} VkDescriptorPoolUsage;
+-
+-typedef enum {
+- VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0,
+- VK_DESCRIPTOR_SET_USAGE_STATIC = 1,
+- VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT,
+- VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC,
+- VK_DESCRIPTOR_SET_USAGE_NUM = (VK_DESCRIPTOR_SET_USAGE_STATIC - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT + 1),
+- VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF
+-} VkDescriptorSetUsage;
+-
+-typedef enum {
+ VK_ATTACHMENT_LOAD_OP_LOAD = 0,
+ VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
+@@ -985,6 +968,12 @@ typedef VkFlags VkPipelineCreateFlags;
+ typedef VkFlags VkShaderStageFlags;
+
+ typedef enum {
++ VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
++} VkDescriptorPoolCreateFlagBits;
++typedef VkFlags VkDescriptorPoolCreateFlags;
++typedef VkFlags VkDescriptorPoolResetFlags;
++
++typedef enum {
+ VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
+ } VkAttachmentDescriptionFlagBits;
+ typedef VkFlags VkAttachmentDescriptionFlags;
+@@ -1043,7 +1032,6 @@ typedef enum {
+ VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+ } VkCmdPoolResetFlagBits;
+ typedef VkFlags VkCmdPoolResetFlags;
+-typedef VkFlags VkCmdBufferCreateFlags;
+
+ typedef enum {
+ VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
+@@ -1125,6 +1113,9 @@ typedef struct {
+ VkBool32 depthBounds;
+ VkBool32 wideLines;
+ VkBool32 largePoints;
++ VkBool32 alphaToOne;
++ VkBool32 multiViewport;
++ VkBool32 samplerAnisotropy;
+ VkBool32 textureCompressionETC2;
+ VkBool32 textureCompressionASTC_LDR;
+ VkBool32 textureCompressionBC;
+@@ -1150,7 +1141,6 @@ typedef struct {
+ VkBool32 shaderInt16;
+ VkBool32 shaderResourceResidency;
+ VkBool32 shaderResourceMinLOD;
+- VkBool32 alphaToOne;
+ VkBool32 sparseBinding;
+ VkBool32 sparseResidencyBuffer;
+ VkBool32 sparseResidencyImage2D;
+@@ -1190,14 +1180,13 @@ typedef struct {
+ uint32_t maxImageArrayLayers;
+ VkSampleCountFlags sampleCounts;
+ uint32_t maxTexelBufferSize;
+- uint32_t maxUniformBufferSize;
+- uint32_t maxStorageBufferSize;
++ uint32_t maxUniformBufferRange;
++ uint32_t maxStorageBufferRange;
+ uint32_t maxPushConstantsSize;
+ uint32_t maxMemoryAllocationCount;
+ VkDeviceSize bufferImageGranularity;
+ VkDeviceSize sparseAddressSpaceSize;
+ uint32_t maxBoundDescriptorSets;
+- uint32_t maxDescriptorSets;
+ uint32_t maxPerStageDescriptorSamplers;
+ uint32_t maxPerStageDescriptorUniformBuffers;
+ uint32_t maxPerStageDescriptorStorageBuffers;
+@@ -1229,8 +1218,8 @@ typedef struct {
+ uint32_t maxGeometryOutputVertices;
+ uint32_t maxGeometryTotalOutputComponents;
+ uint32_t maxFragmentInputComponents;
+- uint32_t maxFragmentOutputBuffers;
+- uint32_t maxFragmentDualSourceBuffers;
++ uint32_t maxFragmentOutputAttachments;
++ uint32_t maxFragmentDualSourceAttachments;
+ uint32_t maxFragmentCombinedOutputResources;
+ uint32_t maxComputeSharedMemorySize;
+ uint32_t maxComputeWorkGroupCount[3];
+@@ -1252,9 +1241,9 @@ typedef struct {
+ uint32_t minTexelBufferOffsetAlignment;
+ uint32_t minUniformBufferOffsetAlignment;
+ uint32_t minStorageBufferOffsetAlignment;
+- uint32_t minTexelOffset;
++ int32_t minTexelOffset;
+ uint32_t maxTexelOffset;
+- uint32_t minTexelGatherOffset;
++ int32_t minTexelGatherOffset;
+ uint32_t maxTexelGatherOffset;
+ float minInterpolationOffset;
+ float maxInterpolationOffset;
+@@ -1275,6 +1264,7 @@ typedef struct {
+ uint32_t maxClipDistances;
+ uint32_t maxCullDistances;
+ uint32_t maxCombinedClipAndCullDistances;
++ uint32_t discreteQueuePriorities;
+ float pointSizeRange[2];
+ float lineWidthRange[2];
+ float pointSizeGranularity;
+@@ -1330,6 +1320,7 @@ typedef struct {
+ const void* pNext;
+ uint32_t queueFamilyIndex;
+ uint32_t queueCount;
++ const float* pQueuePriorities;
+ } VkDeviceQueueCreateInfo;
+
+ typedef struct {
+@@ -1806,13 +1797,21 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkDescriptorPoolUsage poolUsage;
++ VkDescriptorPoolCreateFlags flags;
+ uint32_t maxSets;
+ uint32_t count;
+ const VkDescriptorTypeCount* pTypeCount;
+ } VkDescriptorPoolCreateInfo;
+
+ typedef struct {
++ VkStructureType sType;
++ const void* pNext;
++ VkDescriptorPool descriptorPool;
++ uint32_t count;
++ const VkDescriptorSetLayout* pSetLayouts;
++} VkDescriptorSetAllocInfo;
++
++typedef struct {
+ VkSampler sampler;
+ VkImageView imageView;
+ VkImageLayout imageLayout;
+@@ -1824,12 +1823,6 @@ typedef struct {
+ VkDeviceSize range;
+ } VkDescriptorBufferInfo;
+
+-typedef union {
+- VkDescriptorImageInfo imageInfo;
+- VkDescriptorBufferInfo bufferInfo;
+- VkBufferView texelBufferView;
+-} VkDescriptorInfo;
+-
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+@@ -1838,7 +1831,9 @@ typedef struct {
+ uint32_t destArrayElement;
+ uint32_t count;
+ VkDescriptorType descriptorType;
+- const VkDescriptorInfo* pDescriptors;
++ const VkDescriptorImageInfo* pImageInfo;
++ const VkDescriptorBufferInfo* pBufferInfo;
++ const VkBufferView* pTexelBufferView;
+ } VkWriteDescriptorSet;
+
+ typedef struct {
+@@ -1933,8 +1928,8 @@ typedef struct {
+ const void* pNext;
+ VkCmdPool cmdPool;
+ VkCmdBufferLevel level;
+- VkCmdBufferCreateFlags flags;
+-} VkCmdBufferCreateInfo;
++ uint32_t count;
++} VkCmdBufferAllocInfo;
+
+ typedef struct {
+ VkStructureType sType;
+@@ -2167,8 +2162,8 @@ typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const
+ typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
+ typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
+ typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
+-typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
+-typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets);
++typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
++typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
+ typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
+ typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+ typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
+@@ -2179,8 +2174,8 @@ typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPa
+ typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
+ typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool);
+ typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
+-typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
+-typedef void (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer);
++typedef VkResult (VKAPI *PFN_vkAllocCommandBuffers)(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
++typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers);
+ typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
+ typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
+ typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
+@@ -2641,14 +2636,12 @@ void VKAPI vkDestroyDescriptorPool(
+
+ VkResult VKAPI vkResetDescriptorPool(
+ VkDevice device,
+- VkDescriptorPool descriptorPool);
++ VkDescriptorPool descriptorPool,
++ VkDescriptorPoolResetFlags flags);
+
+ VkResult VKAPI vkAllocDescriptorSets(
+ VkDevice device,
+- VkDescriptorPool descriptorPool,
+- VkDescriptorSetUsage setUsage,
+- uint32_t count,
+- const VkDescriptorSetLayout* pSetLayouts,
++ const VkDescriptorSetAllocInfo* pAllocInfo,
+ VkDescriptorSet* pDescriptorSets);
+
+ VkResult VKAPI vkFreeDescriptorSets(
+@@ -2701,14 +2694,16 @@ VkResult VKAPI vkResetCommandPool(
+ VkCmdPool cmdPool,
+ VkCmdPoolResetFlags flags);
+
+-VkResult VKAPI vkCreateCommandBuffer(
++VkResult VKAPI vkAllocCommandBuffers(
+ VkDevice device,
+- const VkCmdBufferCreateInfo* pCreateInfo,
+- VkCmdBuffer* pCmdBuffer);
++ const VkCmdBufferAllocInfo* pAllocInfo,
++ VkCmdBuffer* pCmdBuffers);
+
+-void VKAPI vkDestroyCommandBuffer(
++void VKAPI vkFreeCommandBuffers(
+ VkDevice device,
+- VkCmdBuffer commandBuffer);
++ VkCmdPool cmdPool,
++ uint32_t count,
++ const VkCmdBuffer* pCommandBuffers);
+
+ VkResult VKAPI vkBeginCommandBuffer(
+ VkCmdBuffer cmdBuffer,
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index da3837e..0af3bc8 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -457,13 +457,13 @@ void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {
+- return GetVtbl(device).ResetDescriptorPool(device, descriptorPool);
++VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
++ return GetVtbl(device).ResetDescriptorPool(device, descriptorPool, flags);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets) {
+- return GetVtbl(device).AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets);
++VkResult vkAllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets) {
++ return GetVtbl(device).AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
+ }
+
+ __attribute__((visibility("default")))
+@@ -517,13 +517,13 @@ VkResult vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFl
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) {
+- return vulkan::CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
++VkResult vkAllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers) {
++ return GetVtbl(device).AllocCommandBuffers(device, pAllocInfo, pCmdBuffers);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer commandBuffer) {
+- GetVtbl(device).DestroyCommandBuffer(device, commandBuffer);
++void vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers) {
++ GetVtbl(device).FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
+index bd16ac5..b9bd689 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp
++++ b/vulkan/libvulkan/get_proc_addr.cpp
+@@ -69,6 +69,7 @@ const NameProcEntry kInstanceProcTbl[] = {
+ const NameProcEntry kDeviceProcTbl[] = {
+ // clang-format off
+ {"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR)},
++ {"vkAllocCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkAllocCommandBuffers)},
+ {"vkAllocDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkAllocDescriptorSets)},
+ {"vkAllocMemory", reinterpret_cast<PFN_vkVoidFunction>(vkAllocMemory)},
+ {"vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkBeginCommandBuffer)},
+@@ -120,7 +121,6 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkCmdWriteTimestamp", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp)},
+ {"vkCreateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBuffer)},
+ {"vkCreateBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferView)},
+- {"vkCreateCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateCommandBuffer)},
+ {"vkCreateCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateCommandPool)},
+ {"vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateComputePipelines)},
+ {"vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorPool)},
+@@ -142,7 +142,6 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR)},
+ {"vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer)},
+ {"vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferView)},
+- {"vkDestroyCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandBuffer)},
+ {"vkDestroyCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandPool)},
+ {"vkDestroyDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorPool)},
+ {"vkDestroyDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorSetLayout)},
+@@ -165,6 +164,7 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkDeviceWaitIdle)},
+ {"vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkEndCommandBuffer)},
+ {"vkFlushMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkFlushMappedMemoryRanges)},
++ {"vkFreeCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkFreeCommandBuffers)},
+ {"vkFreeDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkFreeDescriptorSets)},
+ {"vkFreeMemory", reinterpret_cast<PFN_vkVoidFunction>(vkFreeMemory)},
+ {"vkGetBufferMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements)},
+@@ -229,6 +229,7 @@ const NameOffsetEntry kInstanceOffsetTbl[] = {
+ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ // clang-format off
+ {"vkAcquireNextImageKHR", offsetof(DeviceVtbl, AcquireNextImageKHR)},
++ {"vkAllocCommandBuffers", offsetof(DeviceVtbl, AllocCommandBuffers)},
+ {"vkAllocDescriptorSets", offsetof(DeviceVtbl, AllocDescriptorSets)},
+ {"vkAllocMemory", offsetof(DeviceVtbl, AllocMemory)},
+ {"vkBeginCommandBuffer", offsetof(DeviceVtbl, BeginCommandBuffer)},
+@@ -280,7 +281,6 @@ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ {"vkCmdWriteTimestamp", offsetof(DeviceVtbl, CmdWriteTimestamp)},
+ {"vkCreateBuffer", offsetof(DeviceVtbl, CreateBuffer)},
+ {"vkCreateBufferView", offsetof(DeviceVtbl, CreateBufferView)},
+- {"vkCreateCommandBuffer", offsetof(DeviceVtbl, CreateCommandBuffer)},
+ {"vkCreateCommandPool", offsetof(DeviceVtbl, CreateCommandPool)},
+ {"vkCreateComputePipelines", offsetof(DeviceVtbl, CreateComputePipelines)},
+ {"vkCreateDescriptorPool", offsetof(DeviceVtbl, CreateDescriptorPool)},
+@@ -302,7 +302,6 @@ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ {"vkCreateSwapchainKHR", offsetof(DeviceVtbl, CreateSwapchainKHR)},
+ {"vkDestroyBuffer", offsetof(DeviceVtbl, DestroyBuffer)},
+ {"vkDestroyBufferView", offsetof(DeviceVtbl, DestroyBufferView)},
+- {"vkDestroyCommandBuffer", offsetof(DeviceVtbl, DestroyCommandBuffer)},
+ {"vkDestroyCommandPool", offsetof(DeviceVtbl, DestroyCommandPool)},
+ {"vkDestroyDescriptorPool", offsetof(DeviceVtbl, DestroyDescriptorPool)},
+ {"vkDestroyDescriptorSetLayout", offsetof(DeviceVtbl, DestroyDescriptorSetLayout)},
+@@ -325,6 +324,7 @@ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ {"vkDeviceWaitIdle", offsetof(DeviceVtbl, DeviceWaitIdle)},
+ {"vkEndCommandBuffer", offsetof(DeviceVtbl, EndCommandBuffer)},
+ {"vkFlushMappedMemoryRanges", offsetof(DeviceVtbl, FlushMappedMemoryRanges)},
++ {"vkFreeCommandBuffers", offsetof(DeviceVtbl, FreeCommandBuffers)},
+ {"vkFreeDescriptorSets", offsetof(DeviceVtbl, FreeDescriptorSets)},
+ {"vkFreeMemory", offsetof(DeviceVtbl, FreeMemory)},
+ {"vkGetBufferMemoryRequirements", offsetof(DeviceVtbl, GetBufferMemoryRequirements)},
+@@ -896,14 +896,14 @@ bool LoadDeviceVtbl(VkDevice device,
+ ALOGE("missing device proc: %s", "vkResetCommandPool");
+ success = false;
+ }
+- vtbl.CreateCommandBuffer = reinterpret_cast<PFN_vkCreateCommandBuffer>(get_proc_addr(device, "vkCreateCommandBuffer"));
+- if (UNLIKELY(!vtbl.CreateCommandBuffer)) {
+- ALOGE("missing device proc: %s", "vkCreateCommandBuffer");
++ vtbl.AllocCommandBuffers = reinterpret_cast<PFN_vkAllocCommandBuffers>(get_proc_addr(device, "vkAllocCommandBuffers"));
++ if (UNLIKELY(!vtbl.AllocCommandBuffers)) {
++ ALOGE("missing device proc: %s", "vkAllocCommandBuffers");
+ success = false;
+ }
+- vtbl.DestroyCommandBuffer = reinterpret_cast<PFN_vkDestroyCommandBuffer>(get_proc_addr(device, "vkDestroyCommandBuffer"));
+- if (UNLIKELY(!vtbl.DestroyCommandBuffer)) {
+- ALOGE("missing device proc: %s", "vkDestroyCommandBuffer");
++ vtbl.FreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(get_proc_addr(device, "vkFreeCommandBuffers"));
++ if (UNLIKELY(!vtbl.FreeCommandBuffers)) {
++ ALOGE("missing device proc: %s", "vkFreeCommandBuffers");
+ success = false;
+ }
+ vtbl.BeginCommandBuffer = reinterpret_cast<PFN_vkBeginCommandBuffer>(get_proc_addr(device, "vkBeginCommandBuffer"));
+diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
+index ba2f5cf..c427918 100644
+--- a/vulkan/libvulkan/loader.cpp
++++ b/vulkan/libvulkan/loader.cpp
+@@ -1047,8 +1047,8 @@ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* name) {
+ if (strcmp(name, "vkGetDeviceQueue") == 0) {
+ return reinterpret_cast<PFN_vkVoidFunction>(GetDeviceQueue);
+ }
+- if (strcmp(name, "vkCreateCommandBuffer") == 0) {
+- return reinterpret_cast<PFN_vkVoidFunction>(CreateCommandBuffer);
++ if (strcmp(name, "vkAllocCommandBuffers") == 0) {
++ return reinterpret_cast<PFN_vkVoidFunction>(AllocCommandBuffers);
+ }
+ if (strcmp(name, "vkDestroyDevice") == 0) {
+ return reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice);
+@@ -1072,24 +1072,21 @@ void GetDeviceQueue(VkDevice drv_device,
+ *out_queue = queue;
+ }
+
+-VkResult CreateCommandBuffer(VkDevice drv_device,
+- const VkCmdBufferCreateInfo* create_info,
+- VkCmdBuffer* out_cmdbuf) {
+- const DeviceVtbl* vtbl = GetVtbl(drv_device);
+- VkCmdBuffer cmdbuf;
+- VkResult result =
+- vtbl->CreateCommandBuffer(drv_device, create_info, &cmdbuf);
++VkResult AllocCommandBuffers(VkDevice device,
++ const VkCmdBufferAllocInfo* alloc_info,
++ VkCmdBuffer* cmdbuffers) {
++ const DeviceVtbl* vtbl = GetVtbl(device);
++ VkResult result = vtbl->AllocCommandBuffers(device, alloc_info, cmdbuffers);
+ if (result != VK_SUCCESS)
+ return result;
+- hwvulkan_dispatch_t* dispatch =
+- reinterpret_cast<hwvulkan_dispatch_t*>(cmdbuf);
+- if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
+- ALOGE("invalid VkCmdBuffer dispatch magic: 0x%" PRIxPTR,
+- dispatch->magic);
+- return VK_ERROR_INITIALIZATION_FAILED;
++ for (uint32_t i = 0; i < alloc_info->count; i++) {
++ hwvulkan_dispatch_t* dispatch =
++ reinterpret_cast<hwvulkan_dispatch_t*>(cmdbuffers[i]);
++ ALOGE_IF(dispatch->magic != HWVULKAN_DISPATCH_MAGIC,
++ "invalid VkCmdBuffer dispatch magic: 0x%" PRIxPTR,
++ dispatch->magic);
++ dispatch->vtbl = vtbl;
+ }
+- dispatch->vtbl = vtbl;
+- *out_cmdbuf = cmdbuf;
+ return VK_SUCCESS;
+ }
+
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index fcaec61..5e0a6c9 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -131,8 +131,8 @@ struct DeviceVtbl {
+ PFN_vkCreateCommandPool CreateCommandPool;
+ PFN_vkDestroyCommandPool DestroyCommandPool;
+ PFN_vkResetCommandPool ResetCommandPool;
+- PFN_vkCreateCommandBuffer CreateCommandBuffer;
+- PFN_vkDestroyCommandBuffer DestroyCommandBuffer;
++ PFN_vkAllocCommandBuffers AllocCommandBuffers;
++ PFN_vkFreeCommandBuffers FreeCommandBuffers;
+
+ PFN_vkQueueSubmit QueueSubmit;
+ PFN_vkQueueWaitIdle QueueWaitIdle;
+@@ -225,9 +225,9 @@ void GetDeviceQueue(VkDevice drv_device,
+ uint32_t family,
+ uint32_t index,
+ VkQueue* out_queue);
+-VkResult CreateCommandBuffer(VkDevice device,
+- const VkCmdBufferCreateInfo* create_info,
+- VkCmdBuffer* out_cmdbuf);
++VkResult AllocCommandBuffers(VkDevice device,
++ const VkCmdBufferAllocInfo* alloc_info,
++ VkCmdBuffer* cmdbuffers);
+ VkResult DestroyDevice(VkDevice drv_device);
+
+ void* AllocDeviceMem(VkDevice device,
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index f07dfa7..7e890be 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -339,23 +339,41 @@ void GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
+ // -----------------------------------------------------------------------------
+ // CmdBuffer
+
+-VkResult CreateCommandBuffer(VkDevice device,
+- const VkCmdBufferCreateInfo*,
+- VkCmdBuffer* out_cmdbuf) {
++VkResult AllocCommandBuffers(VkDevice device,
++ const VkCmdBufferAllocInfo* alloc_info,
++ VkCmdBuffer* cmdbufs) {
++ VkResult result = VK_SUCCESS;
+ const VkAllocCallbacks* alloc = device->instance->alloc;
+- VkCmdBuffer_T* cmdbuf = static_cast<VkCmdBuffer_T*>(alloc->pfnAlloc(
+- alloc->pUserData, sizeof(VkCmdBuffer_T), alignof(VkCmdBuffer_T),
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
+- if (!cmdbuf)
+- return VK_ERROR_OUT_OF_HOST_MEMORY;
+- cmdbuf->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
+- *out_cmdbuf = cmdbuf;
+- return VK_SUCCESS;
++
++ std::fill(cmdbufs, cmdbufs + alloc_info->count, nullptr);
++ for (uint32_t i = 0; i < alloc_info->count; i++) {
++ cmdbufs[i] = static_cast<VkCmdBuffer_T*>(alloc->pfnAlloc(
++ alloc->pUserData, sizeof(VkCmdBuffer_T), alignof(VkCmdBuffer_T),
++ VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
++ if (!cmdbufs[i]) {
++ result = VK_ERROR_OUT_OF_HOST_MEMORY;
++ break;
++ }
++ cmdbufs[i]->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
++ }
++ if (result != VK_SUCCESS) {
++ for (uint32_t i = 0; i < alloc_info->count; i++) {
++ if (!cmdbufs[i])
++ break;
++ alloc->pfnFree(alloc->pUserData, cmdbufs[i]);
++ }
++ }
++
++ return result;
+ }
+
+-void DestroyCommandBuffer(VkDevice device, VkCmdBuffer cmdbuf) {
++void FreeCommandBuffers(VkDevice device,
++ VkCmdPool,
++ uint32_t count,
++ const VkCmdBuffer* cmdbufs) {
+ const VkAllocCallbacks* alloc = device->instance->alloc;
+- alloc->pfnFree(alloc->pUserData, cmdbuf);
++ for (uint32_t i = 0; i < count; i++)
++ alloc->pfnFree(alloc->pUserData, cmdbufs[i]);
+ }
+
+ // -----------------------------------------------------------------------------
+@@ -535,13 +553,10 @@ VkResult CreateDescriptorPool(VkDevice device,
+ }
+
+ VkResult AllocDescriptorSets(VkDevice device,
+- VkDescriptorPool,
+- VkDescriptorSetUsage,
+- uint32_t count,
+- const VkDescriptorSetLayout*,
+- VkDescriptorSet* sets) {
+- for (uint32_t i = 0; i < count; i++)
+- sets[i] = AllocHandle(device, HandleType::kDescriptorSet);
++ const VkDescriptorSetAllocInfo* alloc_info,
++ VkDescriptorSet* descriptor_sets) {
++ for (uint32_t i = 0; i < alloc_info->count; i++)
++ descriptor_sets[i] = AllocHandle(device, HandleType::kDescriptorSet);
+ return VK_SUCCESS;
+ }
+
+@@ -874,7 +889,7 @@ void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descripto
+ void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {
+ }
+
+-VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {
++VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ return VK_SUCCESS;
+ }
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 655a414..c35df18 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -109,8 +109,8 @@ VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutC
+ void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
+ VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
+ void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool);
+-VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool);
+-VkResult AllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets);
++VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
++VkResult AllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
+ VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
+ void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+ VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
+@@ -121,8 +121,8 @@ void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent
+ VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
+ void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool);
+ VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
+-VkResult CreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
+-void DestroyCommandBuffer(VkDevice device, VkCmdBuffer commandBuffer);
++VkResult AllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
++void FreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers);
+ VkResult BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
+ VkResult EndCommandBuffer(VkCmdBuffer cmdBuffer);
+ VkResult ResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
+diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
+index e86a795..431977d 100644
+--- a/vulkan/nulldrv/null_driver_gen.cpp
++++ b/vulkan/nulldrv/null_driver_gen.cpp
+@@ -67,6 +67,7 @@ const NameProcEntry kInstanceProcTbl[] = {
+
+ const NameProcEntry kDeviceProcTbl[] = {
+ // clang-format off
++ {"vkAllocCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocCommandBuffers>(AllocCommandBuffers))},
+ {"vkAllocDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocDescriptorSets>(AllocDescriptorSets))},
+ {"vkAllocMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocMemory>(AllocMemory))},
+ {"vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkBeginCommandBuffer>(BeginCommandBuffer))},
+@@ -118,7 +119,6 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkCmdWriteTimestamp", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCmdWriteTimestamp>(CmdWriteTimestamp))},
+ {"vkCreateBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateBuffer>(CreateBuffer))},
+ {"vkCreateBufferView", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateBufferView>(CreateBufferView))},
+- {"vkCreateCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateCommandBuffer>(CreateCommandBuffer))},
+ {"vkCreateCommandPool", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateCommandPool>(CreateCommandPool))},
+ {"vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateComputePipelines>(CreateComputePipelines))},
+ {"vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDescriptorPool>(CreateDescriptorPool))},
+@@ -139,7 +139,6 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateShaderModule>(CreateShaderModule))},
+ {"vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyBuffer>(DestroyBuffer))},
+ {"vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyBufferView>(DestroyBufferView))},
+- {"vkDestroyCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyCommandBuffer>(DestroyCommandBuffer))},
+ {"vkDestroyCommandPool", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyCommandPool>(DestroyCommandPool))},
+ {"vkDestroyDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyDescriptorPool>(DestroyDescriptorPool))},
+ {"vkDestroyDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyDescriptorSetLayout>(DestroyDescriptorSetLayout))},
+@@ -161,6 +160,7 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDeviceWaitIdle>(DeviceWaitIdle))},
+ {"vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEndCommandBuffer>(EndCommandBuffer))},
+ {"vkFlushMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkFlushMappedMemoryRanges>(FlushMappedMemoryRanges))},
++ {"vkFreeCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkFreeCommandBuffers>(FreeCommandBuffers))},
+ {"vkFreeDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkFreeDescriptorSets>(FreeDescriptorSets))},
+ {"vkFreeMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkFreeMemory>(FreeMemory))},
+ {"vkGetBufferMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetBufferMemoryRequirements>(GetBufferMemoryRequirements))},
+--
+2.4.0
+
--- /dev/null
+From 8e7c3261d591b7df086683fb7877e188aee7c1f8 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 23 Nov 2015 17:24:58 -0800
+Subject: [PATCH 07/30] vulkan: Implement VkSurfaceKHR and use vulkanext.h
+
+Between header version 0.183.0 and 0.184.0, a copy of vulkan.h which
+includes extensions was added to the registry, called vulkanext.h. The
+vulkan.h included here is actually the registry's vulkanext.h.
+(In a later upstream change, the no-extensions version was removed
+from the registry, and vulkanext.h was renamed vulkan.h, matching what
+we're doing here.)
+
+The version of the extensions picked up in the header file is later
+than the ones used in the previous SDK, so this change also updates
+our implementation to the extension versions included in the header.
+The main change is replacing the VkSurfaceDescriptionKHR structure
+with a VkSurfaceKHR object.
+
+Change-Id: I18fa5a269db0fcdbdbde3e9304167bc15e456f85
+---
+ vulkan/api/platform.api | 23 +
+ vulkan/api/vulkan.api | 469 ++++++++++++++++-----
+ .../include/vulkan/vk_ext_khr_device_swapchain.h | 210 ---------
+ vulkan/include/vulkan/vk_ext_khr_swapchain.h | 153 -------
+ vulkan/include/vulkan/vk_platform.h | 28 ++
+ vulkan/include/vulkan/vulkan.h | 432 +++++++++++++++++++
+ vulkan/libvulkan/entry.cpp | 34 +-
+ vulkan/libvulkan/entry.cpp.tmpl | 22 +-
+ vulkan/libvulkan/get_proc_addr.cpp | 6 +
+ vulkan/libvulkan/get_proc_addr.cpp.tmpl | 39 +-
+ vulkan/libvulkan/loader.cpp | 23 +-
+ vulkan/libvulkan/loader.h | 38 +-
+ vulkan/libvulkan/swapchain.cpp | 239 +++++------
+ 13 files changed, 1062 insertions(+), 654 deletions(-)
+ delete mode 100644 vulkan/include/vulkan/vk_ext_khr_device_swapchain.h
+ delete mode 100644 vulkan/include/vulkan/vk_ext_khr_swapchain.h
+
+diff --git a/vulkan/api/platform.api b/vulkan/api/platform.api
+index 23f649d..889ac2c 100644
+--- a/vulkan/api/platform.api
++++ b/vulkan/api/platform.api
+@@ -22,3 +22,26 @@
+ // Platform types, as defined or included in vk_platform.h
+
+ type u64 size_t
++
++// VK_USE_PLATFORM_X11_KHR
++@internal class Display {}
++@internal class Window {}
++
++// VK_USE_PLATFORM_XCB_KHR
++@internal class xcb_connection_t {}
++@internal type u32 xcb_window_t
++
++// VK_USE_PLATFORM_WAYLAND_KHR
++@internal class wl_display {}
++@internal class wl_surface {}
++
++// VK_USE_PLATFORM_MIR_KHR
++@internal class MirConnection {}
++@internal class MirSurface {}
++
++// VK_USE_PLATFORM_ANDROID_KHR
++@internal class ANativeWindow {}
++
++// VK_USE_PLATFORM_WIN32_KHR
++@internal type void* HINSTANCE
++@internal type void* HWND
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 175e353..878cf44 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -45,6 +45,46 @@ define VK_FALSE 0
+ // API keyword, but needs special handling by some templates
+ define NULL_HANDLE 0
+
++@extension("VK_EXT_KHR_surface") define VK_EXT_KHR_SURFACE_REVISION 19
++@extension("VK_EXT_KHR_surface") define VK_EXT_KHR_SURFACE_EXTENSION_NUMBER 1
++@extension("VK_EXT_KHR_surface") define VK_EXT_KHR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_surface"
++
++@extension("VK_EXT_KHR_swapchain") define VK_EXT_KHR_SWAPCHAIN_REVISION 59
++@extension("VK_EXT_KHR_swapchain") define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
++@extension("VK_EXT_KHR_swapchain") define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
++
++@extension("VK_EXT_KHR_display") define VK_EXT_KHR_DISPLAY_REVISION 16
++@extension("VK_EXT_KHR_display") define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 3
++@extension("VK_EXT_KHR_display") define VK_EXT_KHR_DISPLAY_EXTENSION_NAME "VK_EXT_KHR_display"
++
++@extension("VK_EXT_KHR_display_swapchain") define VK_EXT_KHR_DISPLAY_REVISION 14
++@extension("VK_EXT_KHR_display_swapchain") define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 4
++@extension("VK_EXT_KHR_display_swapchain") define VK_EXT_KHR_DISPLAY_EXTENSION_NAME "VK_EXT_KHR_display_swapchain"
++
++@extension("VK_EXT_KHR_x11_surface") define VK_EXT_KHR_X11_SURFACE_REVISION 1
++@extension("VK_EXT_KHR_x11_surface") define VK_EXT_KHR_X11_SURFACE_NUMBER 4
++@extension("VK_EXT_KHR_x11_surface") define VK_EXT_KHR_X11_SURFACE_NAME "VK_EXT_KHR_x11_surface"
++
++@extension("VK_EXT_KHR_xcb_surface") define VK_EXT_KHR_XCB_SURFACE_REVISION 1
++@extension("VK_EXT_KHR_xcb_surface") define VK_EXT_KHR_XCB_SURFACE_NUMBER 6
++@extension("VK_EXT_KHR_xcb_surface") define VK_EXT_KHR_XCB_SURFACE_NAME "VK_EXT_KHR_xcb_surface"
++
++@extension("VK_EXT_KHR_wayland_surface") define VK_EXT_KHR_WAYLAND_SURFACE_REVISION 1
++@extension("VK_EXT_KHR_wayland_surface") define VK_EXT_KHR_WAYLAND_SURFACE_NUMBER 7
++@extension("VK_EXT_KHR_wayland_surface") define VK_EXT_KHR_WAYLAND_SURFACE_NAME "VK_EXT_KHR_wayland_surface"
++
++@extension("VK_EXT_KHR_mir_surface") define VK_EXT_KHR_MIR_SURFACE_REVISION 1
++@extension("VK_EXT_KHR_mir_surface") define VK_EXT_KHR_MIR_SURFACE_NUMBER 8
++@extension("VK_EXT_KHR_mir_surface") define VK_EXT_KHR_MIR_SURFACE_NAME "VK_EXT_KHR_mir_surface"
++
++@extension("VK_EXT_KHR_android_surface") define VK_EXT_KHR_ANDROID_SURFACE_REVISION 1
++@extension("VK_EXT_KHR_android_surface") define VK_EXT_KHR_ANDROID_SURFACE_NUMBER 8
++@extension("VK_EXT_KHR_android_surface") define VK_EXT_KHR_ANDROID_SURFACE_NAME "VK_EXT_KHR_android_surface"
++
++@extension("VK_EXT_KHR_win32_surface") define VK_EXT_KHR_WIN32_SURFACE_REVISION 1
++@extension("VK_EXT_KHR_win32_surface") define VK_EXT_KHR_WIN32_SURFACE_NUMBER 9
++@extension("VK_EXT_KHR_win32_surface") define VK_EXT_KHR_WIN32_SURFACE_NAME "VK_EXT_KHR_win32_surface"
++
+
+ /////////////
+ // Types //
+@@ -84,7 +124,13 @@ type u32 VkSampleMask
+ @nonDispatchHandle type u64 VkFramebuffer
+ @nonDispatchHandle type u64 VkRenderPass
+ @nonDispatchHandle type u64 VkPipelineCache
+-@nonDispatchHandle type u64 VkSwapchainKHR
++
++@extension("VK_EXT_KHR_surface") @nonDispatchHandle type u64 VkSurfaceKHR
++
++@extension("VK_EXT_KHR_swapchain") @nonDispatchHandle type u64 VkSwapchainKHR
++
++@extension("VK_EXT_KHR_display") @nonDispatchHandle type u64 VkDisplayKHR
++@extension("VK_EXT_KHR_display") @nonDispatchHandle type u64 VkDisplayModeKHR
+
+
+ /////////////
+@@ -101,6 +147,9 @@ enum VkImageLayout {
+ VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000006, /// Optimal layout when image is used only as source of transfer operations
+ VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000007, /// Optimal layout when image is used only as destination of transfer operations
+ VK_IMAGE_LAYOUT_PREINITIALIZED = 0x00000008, /// Initial layout used when the data is populated by the CPU
++
++ //@extension("VK_EXT_KHR_swapchain")
++ VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR = 0xc0000802,
+ }
+
+ enum VkAttachmentLoadOp {
+@@ -568,6 +617,17 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45,
+ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 47,
++
++ //@extension("VK_EXT_KHR_swapchain")
++ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 0xc0000801,
++
++ //@extension("VK_EXT_KHR_display")
++ VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 0xc0000c00,
++ VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_DISPLAY_PLAN_KHR = 0xc0000c01,
++
++ //@extension("VK_EXT_KHR_display_swapchain")
++ VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR = 0xc0001000,
++ VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR = 0xc0001001,
+ }
+
+ enum VkRenderPassContents {
+@@ -586,6 +646,9 @@ enum VkResult {
+ VK_EVENT_RESET = 0x00000004,
+ VK_INCOMPLETE = 0x00000005,
+
++ //@extension("VK_EXT_KHR_swapchain")
++ VK_SUBOPTIMAL_KHR = 0x40000403,
++
+ // Error codes (negative values)
+ VK_ERROR_OUT_OF_HOST_MEMORY = 0xFFFFFFFF,
+ VK_ERROR_OUT_OF_DEVICE_MEMORY = 0xFFFFFFFE,
+@@ -596,6 +659,16 @@ enum VkResult {
+ VK_ERROR_EXTENSION_NOT_PRESENT = 0xFFFFFFF9,
+ VK_ERROR_FEATURE_NOT_PRESENT = 0xFFFFFFF8,
+ VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF7,
++
++ //@extension("VK_EXT_KHR_swapchain")
++ VK_ERROR_OUT_OF_DATE_KHR = 0xC0000804,
++
++ //@extension("VK_EXT_KHR_display_swapchain")
++ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC0001002,
++
++ //@extension("VK_EXT_KHR_android_surface")
++ VK_ERROR_INVALID_ANDROID_WINDOW_KHR = 0xC002400,
++ VK_ERROR_ANDROID_WINDOW_IN_USE_KHR = 0xC002401,
+ }
+
+ enum VkDynamicState {
+@@ -610,11 +683,7 @@ enum VkDynamicState {
+ VK_DYNAMIC_STATE_STENCIL_REFERENCE = 0x00000008,
+ }
+
+-//////////////////
+-// Extensions //
+-//////////////////
+-
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_EXT_KHR_surface")
+ enum VkSurfaceTransformKHR {
+ VK_SURFACE_TRANSFORM_NONE_KHR = 0x00000000,
+ VK_SURFACE_TRANSFORM_ROT90_KHR = 0x00000001,
+@@ -628,23 +697,13 @@ enum VkSurfaceTransformKHR {
+ }
+
+ @extension("VK_EXT_KHR_swapchain")
+-enum VkPlatformKHR {
+- VK_PLATFORM_WIN32_KHR = 0x00000000,
+- VK_PLATFORM_X11_KHR = 0x00000001,
+- VK_PLATFORM_XCB_KHR = 0x00000002,
+- VK_PLATFORM_ANDROID_KHR = 0x00000003,
+- VK_PLATFORM_WAYLAND_KHR = 0x00000004,
+- VK_PLATFORM_MIR_KHR = 0x00000005,
+-}
+-
+-@extension("VK_EXT_KHR_device_swapchain")
+ enum VkPresentModeKHR {
+ VK_PRESENT_MODE_IMMEDIATE_KHR = 0x00000000,
+ VK_PRESENT_MODE_MAILBOX_KHR = 0x00000001,
+ VK_PRESENT_MODE_FIFO_KHR = 0x00000002,
+ }
+
+-@extension("VK_EXT_KHR_device_swapchain")
++@extension("VK_EXT_KHR_swapchain")
+ enum VkColorSpaceKHR {
+ VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0x00000000,
+ }
+@@ -941,10 +1000,6 @@ bitfield VkStencilFaceFlags {
+ VK_STENCIL_FACE_BACK_BIT = 0x00000002, /// Back face
+ }
+
+-//////////////////
+-// Extensions //
+-//////////////////
+-
+ @extension("VK_EXT_KHR_swapchain")
+ bitfield VkSurfaceTransformFlagsKHR {
+ VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
+@@ -958,6 +1013,14 @@ bitfield VkSurfaceTransformFlagsKHR {
+ VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
+ }
+
++@extension("VK_EXT_KHR_display")
++bitfield VkDisplayPlaneAlphaFlagsKHR {
++ VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000001,
++ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000002,
++ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000004,
++}
++
++
+ //////////////////
+ // Structures //
+ //////////////////
+@@ -1995,73 +2058,136 @@ class VkDispatchIndirectCmd {
+ u32 z
+ }
+
+-//////////////////
+-// Extensions //
+-//////////////////
+-
+-@extension("VK_EXT_KHR_device_swapchain")
++@extension("VK_EXT_KHR_swapchain")
+ class VkSurfacePropertiesKHR {
+- u32 minImageCount
+- u32 maxImageCount
+- VkExtent2D currentExtent
+- VkExtent2D minImageExtent
+- VkExtent2D maxImageExtent
+- VkSurfaceTransformFlagsKHR supportedTransforms
+- VkSurfaceTransformKHR currentTransform
+- u32 maxImageArraySize
+- VkImageUsageFlags supportedUsageFlags
+-}
+-
+-@extension("VK_EXT_KHR_device_swapchain")
+-class VkSurfaceFormatKHR {
+- VkFormat format
+- VkColorSpaceKHR colorSpace
++ u32 minImageCount
++ u32 maxImageCount
++ VkExtent2D currentExtent
++ VkExtent2D minImageExtent
++ VkExtent2D maxImageExtent
++ VkSurfaceTransformFlagsKHR supportedTransforms
++ VkSurfaceTransformKHR currentTransform
++ u32 maxImageArraySize
++ VkImageUsageFlags supportedUsageFlags
+ }
+
+-@extension("VK_EXT_KHR_device_swapchain")
+-class VkSwapchainCreateInfoKHR {
+- VkStructureType sType
+- const void* pNext
+- const VkSurfaceDescriptionKHR* pSurfaceDescription
+- u32 minImageCount
+- VkFormat imageFormat
+- VkColorSpaceKHR imageColorSpace
+- VkExtent2D imageExtent
+- VkImageUsageFlags imageUsageFlags
+- VkSurfaceTransformKHR preTransform
+- u32 imageArraySize
+- VkSharingMode sharingMode
+- u32 queueFamilyCount
+- const u32* pQueueFamilyIndices
+- VkPresentModeKHR presentMode
+- VkSwapchainKHR oldSwapchain
+- VkBool32 clipped
+-}
+-
+-@extension("VK_EXT_KHR_device_swapchain")
+-class VkPresentInfoKHR {
+- VkStructureType sType
+- const void* pNext
+- u32 swapchainCount
+- const VkSwapchainKHR* swapchains
+- const u32* imageIndices
++@extension("VK_EXT_KHR_swapchain")
++class VkSurfaceFormatKHR {
++ VkFormat format
++ VkColorSpaceKHR colorSpace
+ }
+
+ @extension("VK_EXT_KHR_swapchain")
+-class VkSurfaceDescriptionKHR {
+- VkStructureType sType
+- const void* pNext
++class VkSwapchainCreateInfoKHR {
++ VkStructureType sType
++ const void* pNext
++ VkSurfaceKHR surface
++ u32 minImageCount
++ VkFormat imageFormat
++ VkColorSpaceKHR imageColorSpace
++ VkExtent2D imageExtent
++ VkImageUsageFlags imageUsageFlags
++ VkSurfaceTransformKHR preTransform
++ u32 imageArraySize
++ VkSharingMode sharingMode
++ u32 queueFamilyCount
++ const u32* pQueueFamilyIndices
++ VkPresentModeKHR presentMode
++ VkSwapchainKHR oldSwapchain
++ VkBool32 clipped
+ }
+
+ @extension("VK_EXT_KHR_swapchain")
+-class VkSurfaceDescriptionWindowKHR {
+- VkStructureType sType
+- const void* pNext
+- VkPlatformKHR platform
+- void* pPlatformHandle
+- void* pPlatformWindow
++class VkPresentInfoKHR {
++ VkStructureType sType
++ const void* pNext
++ u32 swapchainCount
++ const VkSwapchainKHR* swapchains
++ const u32* imageIndices
++}
++
++@extension("VK_EXT_KHR_display")
++class VkDisplayPropertiesKHR {
++ VkDisplayKHR display
++ const char* displayName
++ VkExtent2D physicalDimensions
++ VkExtent2D physicalResolution
++ VkSurfaceTransformFlagsKHR supportedTransforms
++ u32 planeCount
++ VkBool32 planeReorderPossible
++}
++
++@extension("VK_EXT_KHR_display")
++class VkDisplayTimingKHR {
++ u32 pixelClock
++ VkExtent2D visibleRegion
++ VkExtent2D totalRegion
++ VkExtent2D physicalDimensions
++ u32 hSyncStart
++ u32 hSyncEnd
++ u32 vSyncStart
++ u32 vSyncEnd
++ VkBool32 interlaced
++ VkBool32 doublescan
++ VkBool32 hSyncPos
++ VkBool32 vSyncPos
++}
++
++@extension("VK_EXT_KHR_display")
++class VkDisplayModePropertiesKHR {
++ VkDisplayModeKHR displayMode
++ VkDisplayTimingKHR timing
++}
++
++@extension("VK_EXT_KHR_display")
++class VkDisplayModeCreateInfoKHR {
++ VkStructureType sType
++ const void* pNext
++ VkDisplayTimingKHR timing
++}
++
++@extension("VK_EXT_KHR_display")
++class VkDisplayPlanePropertiesKHR {
++ VkDisplayPlaneAlphaFlagsKHR supportedAlpha
++ VkOffset2D minSrcPosition
++ VkOffset2D maxSrcPosition
++ VkExtent2D minSrcExtent
++ VkExtent2D maxSrcExtent
++ VkOffset2D minDstPosition
++ VkOffset2D maxDstPosition
++ VkExtent2D minDstExtent
++ VkExtent2D maxDstExtent
++}
++
++@extension("VK_EXT_KHR_display")
++class VkSurfaceDescriptionDisplayPlaneKHR {
++ VkStructureType sType
++ const void* pNext
++ VkDisplayModeKHR displayMode
++ u32 planeIndex
++ u32 planeStackIndex
++ VkSurfaceTransformKHR transform
++ f32 globalAlpha
++ VkDisplayPlaneAlphaFlagsKHR alphaMode
++ VkExtent2D imageSize
++}
++
++@extension("VK_EXT_KHR_display_swapchain")
++class VkDisplaySwapchainCreateInfoKHR {
++ VkStructureType sType
++ const void* pNext
++ const VkSwapchainCreateInfoKHR* pNextSwapchainCreateInfo
++}
++
++@extension("VK_EXT_KHR_display_swapchain")
++class VkDisplayPresentInfoKHR {
++ VkStructureType sType
++ const void* pNext
++ VkRect2D srcRect
++ VkRect2D dstRect
+ }
+
++
+ ////////////////
+ // Commands //
+ ////////////////
+@@ -4296,29 +4422,34 @@ cmd void vkCmdExecuteCommands(
+ }
+ }
+
+-////////////////
+-// Extensions //
+-////////////////
++@extension("VK_EXT_KHR_surface")
++cmd void vkDestroySurfaceKHR(
++ VkInstance instance,
++ VkSurfaceKHR surface) {
++ instanceObject := GetInstance(instance)
++ surfaceObject := GetSurface(surface)
++ assert(surfaceObject.instance == instance)
+
+-@extension("VK_EXT_KHR_swapchain")
+-cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
+- VkPhysicalDevice physicalDevice,
+- u32 queueFamilyIndex,
+- const VkSurfaceDescriptionKHR* pSurfaceDescription,
+- VkBool32* pSupported) {
++ State.Surfaces[surface] = null
++}
++
++@extension("VK_EXT_KHR_surface")
++cmd VkBool32 vkGetPhysicalDeviceSurfaceSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ u32 queueFamilyIndex,
++ VkSurfaceKHR surface) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+
+- supported := ?
+- pSupported[0] = supported
++ //supported := ?
+
+- return ?
++ return ?//supported
+ }
+
+-@extension("VK_EXT_KHR_device_swapchain")
++@extension("VK_EXT_KHR_swapchain")
+ cmd VkResult vkGetSurfacePropertiesKHR(
+- VkDevice device,
+- const VkSurfaceDescriptionKHR* pSurfaceDescription,
+- VkSurfacePropertiesKHR* pSurfaceProperties) {
++ VkDevice device,
++ VkSurfaceKHR surface,
++ VkSurfacePropertiesKHR* pSurfaceProperties) {
+ deviceObject := GetDevice(device)
+
+ surfaceProperties := ?
+@@ -4327,12 +4458,12 @@ cmd VkResult vkGetSurfacePropertiesKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_device_swapchain")
++@extension("VK_EXT_KHR_swapchain")
+ cmd VkResult vkGetSurfaceFormatsKHR(
+- VkDevice device,
+- const VkSurfaceDescriptionKHR* pSurfaceDescription,
+- u32* pCount,
+- VkSurfaceFormatKHR* pSurfaceFormats) {
++ VkDevice device,
++ VkSurfaceKHR surface,
++ u32* pCount,
++ VkSurfaceFormatKHR* pSurfaceFormats) {
+ deviceObject := GetDevice(device)
+
+ count := as!u32(?)
+@@ -4347,12 +4478,12 @@ cmd VkResult vkGetSurfaceFormatsKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_device_swapchain")
++@extension("VK_EXT_KHR_swapchain")
+ cmd VkResult vkGetSurfacePresentModesKHR(
+- VkDevice device,
+- const VkSurfaceDescriptionKHR* pSurfaceDescription,
+- u32* pCount,
+- VkPresentModeKHR* pPresentModes) {
++ VkDevice device,
++ VkSurfaceKHR surface,
++ u32* pCount,
++ VkPresentModeKHR* pPresentModes) {
+ deviceObject := GetDevice(device)
+
+ count := as!u32(?)
+@@ -4367,12 +4498,12 @@ cmd VkResult vkGetSurfacePresentModesKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_device_swapchain")
++@extension("VK_EXT_KHR_swapchain")
+ cmd VkResult vkCreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ VkSwapchainKHR* pSwapchain) {
+- //assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR)
++ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR)
+ deviceObject := GetDevice(device)
+
+ swapchain := ?
+@@ -4382,8 +4513,8 @@ cmd VkResult vkCreateSwapchainKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_device_swapchain")
+-cmd VkResult vkDestroySwapchainKHR(
++@extension("VK_EXT_KHR_swapchain")
++cmd void vkDestroySwapchainKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain) {
+ deviceObject := GetDevice(device)
+@@ -4391,11 +4522,9 @@ cmd VkResult vkDestroySwapchainKHR(
+ assert(swapchainObject.device == device)
+
+ State.Swapchains[swapchain] = null
+-
+- return ?
+ }
+
+-@extension("VK_EXT_KHR_device_swapchain")
++@extension("VK_EXT_KHR_swapchain")
+ cmd VkResult vkGetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+@@ -4410,20 +4539,19 @@ cmd VkResult vkGetSwapchainImagesKHR(
+ for i in (0 .. count) {
+ swapchainImage := ?
+ swapchainImages[i] = swapchainImage
+- if !(swapchainImage in State.Images) {
+- State.Images[swapchainImage] = new!ImageObject(device: device)
+- }
++ State.Images[swapchainImage] = new!ImageObject(device: device)
+ }
+
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_device_swapchain")
++@extension("VK_EXT_KHR_swapchain")
+ cmd VkResult vkAcquireNextImageKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ u64 timeout,
+ VkSemaphore semaphore,
++ VkFence fence,
+ u32* pImageIndex) {
+ deviceObject := GetDevice(device)
+ swapchainObject := GetSwapchain(swapchain)
+@@ -4434,7 +4562,7 @@ cmd VkResult vkAcquireNextImageKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_device_swapchain")
++@extension("VK_EXT_KHR_swapchain")
+ cmd VkResult vkQueuePresentKHR(
+ VkQueue queue,
+ VkPresentInfoKHR* pPresentInfo) {
+@@ -4446,6 +4574,107 @@ cmd VkResult vkQueuePresentKHR(
+ return ?
+ }
+
++@extension("VK_EXT_KHR_display")
++cmd VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
++ VkPhysicalDevice physicalDevice,
++ u32* count,
++ VkDisplayPropertiesKHR* pProperties) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
++ return ?
++}
++
++@extension("VK_EXT_KHR_display")
++cmd VkResult vkGetDisplayModePropertiesKHR(
++ VkPhysicalDevice physicalDevice,
++ VkDisplayKHR display,
++ u32* pCount,
++ VkDisplayModePropertiesKHR* pModeProperties) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
++ return ?
++}
++
++@extension("VK_EXT_KHR_display")
++cmd VkResult vkCreateDisplayModeKHR(
++ VkPhysicalDevice physicalDevice,
++ VkDisplayKHR display,
++ const VkDisplayModeCreateInfoKHR* pCreateInfo,
++ VkDisplayModeKHR* pMode) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
++ return ?
++}
++
++@extension("VK_EXT_KHR_display")
++cmd VkResult vkGetDisplayPlanePropertiesKHR(
++ VkPhysicalDevice physicalDevice,
++ VkDisplayKHR display,
++ VkDisplayModeKHR mode,
++ u32 planeIndex,
++ VkDisplayPlanePropertiesKHR* pProperties) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
++ return ?
++}
++
++@extension("VK_EXT_KHR_x11_surface")
++cmd VkResult vkCreateX11SurfaceKHR(
++ VkInstance instance,
++ platform.Display* dpy,
++ platform.Window root,
++ platform.Window window,
++ VkSurfaceKHR* pSurface) {
++ instanceObject := GetInstance(instance)
++ return ?
++}
++
++@extension("VK_EXT_KHR_xcb_surface")
++cmd VkResult vkCreateXCBSurfaceKHR(
++ VkInstance instance,
++ platform.xcb_connection_t* connection,
++ platform.xcb_window_t root,
++ platform.xcb_window_t window,
++ VkSurfaceKHR* pSurface) {
++ instanceObject := GetInstance(instance)
++ return ?
++}
++
++@extension("VK_EXT_KHR_wayland_surface")
++cmd VkResult vkCreateWaylandSurfaceKHR(
++ VkInstance instance,
++ platform.wl_display* display,
++ platform.wl_surface* surface,
++ VkSurfaceKHR* pSurface) {
++ instanceObject := GetInstance(instance)
++ return ?
++}
++
++@extension("VK_EXT_KHR_mir_surface")
++cmd VkResult vkCreateMirSurfaceKHR(
++ VkInstance instance,
++ platform.MirConnection* connection,
++ platform.MirSurface* mirSurface,
++ VkSurfaceKHR* pSurface) {
++ instanceObject := GetInstance(instance)
++ return ?
++}
++
++@extension("VK_EXT_KHR_android_surface")
++cmd VkResult vkCreateAndroidSurfaceKHR(
++ VkInstance instance,
++ platform.ANativeWindow* window
++ VkSurfaceKHR* pSurface) {
++ instanceObject := GetInstance(instance)
++ return ?
++}
++
++@extension("VK_EXT_KHR_win32_surface")
++cmd VkResult vkCreateWin32SurfaceKHR(
++ VkInstance instance,
++ platform.HINSTANCE hinstance,
++ platform.HWND hwnd,
++ VkSurfaceKHR* pSurface) {
++ instanceObject := GetInstance(instance)
++ return ?
++}
++
+
+ ////////////////
+ // Validation //
+@@ -4490,6 +4719,7 @@ StateObject State
+ map!(VkRenderPass, ref!RenderPassObject) RenderPasses
+ map!(VkPipelineCache, ref!PipelineCacheObject) PipelineCaches
+ map!(VkCmdPool, ref!CmdPoolObject) CmdPools
++ map!(VkSurfaceKHR, ref!SurfaceObject) Surfaces
+ map!(VkSwapchainKHR, ref!SwapchainObject) Swapchains
+ }
+
+@@ -4609,6 +4839,10 @@ StateObject State
+ VkDevice device
+ }
+
++@internal class SurfaceObject {
++ VkInstance instance
++}
++
+ @internal class SwapchainObject {
+ VkDevice device
+ }
+@@ -4743,6 +4977,11 @@ macro ref!CmdPoolObject GetCmdPool(VkCmdPool cmdPool) {
+ return State.CmdPools[cmdPool]
+ }
+
++macro ref!SurfaceObject GetSurface(VkSurfaceKHR surface) {
++ assert(surface in State.Surfaces)
++ return State.Surfaces[surface]
++}
++
+ macro ref!SwapchainObject GetSwapchain(VkSwapchainKHR swapchain) {
+ assert(swapchain in State.Swapchains)
+ return State.Swapchains[swapchain]
+diff --git a/vulkan/include/vulkan/vk_ext_khr_device_swapchain.h b/vulkan/include/vulkan/vk_ext_khr_device_swapchain.h
+deleted file mode 100644
+index 3bf73c8..0000000
+--- a/vulkan/include/vulkan/vk_ext_khr_device_swapchain.h
++++ /dev/null
+@@ -1,210 +0,0 @@
+-//
+-// File: vk_ext_khr_device_swapchain.h
+-//
+-/*
+-** Copyright (c) 2015 The Khronos Group Inc.
+-**
+-** Permission is hereby granted, free of charge, to any person obtaining a
+-** copy of this software and/or associated documentation files (the
+-** "Materials"), to deal in the Materials without restriction, including
+-** without limitation the rights to use, copy, modify, merge, publish,
+-** distribute, sublicense, and/or sell copies of the Materials, and to
+-** permit persons to whom the Materials are furnished to do so, subject to
+-** the following conditions:
+-**
+-** The above copyright notice and this permission notice shall be included
+-** in all copies or substantial portions of the Materials.
+-**
+-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+-*/
+-
+-#ifndef __VK_EXT_KHR_DEVICE_SWAPCHAIN_H__
+-#define __VK_EXT_KHR_DEVICE_SWAPCHAIN_H__
+-
+-#include "vulkan.h"
+-
+-#define VK_EXT_KHR_DEVICE_SWAPCHAIN_REVISION 53
+-#define VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NUMBER 2
+-#define VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_device_swapchain"
+-
+-#ifdef __cplusplus
+-extern "C"
+-{
+-#endif // __cplusplus
+-
+-// ------------------------------------------------------------------------------------------------
+-// Objects
+-
+-VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR);
+-
+-// ------------------------------------------------------------------------------------------------
+-// Enumeration constants
+-
+-#define VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM(type,id) ((type)((int)0xc0000000 - VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NUMBER * -1024 + (id)))
+-#define VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM_POSITIVE(type,id) ((type)((int)0x40000000 + (VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NUMBER - 1) * 1024 + (id)))
+-
+-// Extend VkStructureType enum with extension specific constants
+-#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM(VkStructureType, 0)
+-#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM(VkStructureType, 1)
+-
+-// Extend VkImageLayout enum with extension specific constants
+-#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM(VkImageLayout, 2)
+-
+-// Extend VkResult enum with extension specific constants
+-// Return codes for successful operation execution
+-#define VK_SUBOPTIMAL_KHR VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM_POSITIVE(VkResult, 3)
+-// Error codes
+-#define VK_ERROR_OUT_OF_DATE_KHR VK_EXT_KHR_DEVICE_SWAPCHAIN_ENUM(VkResult, 4)
+-
+-// ------------------------------------------------------------------------------------------------
+-// Enumerations
+-
+-typedef enum {
+- VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
+- VK_PRESENT_MODE_MAILBOX_KHR = 1,
+- VK_PRESENT_MODE_FIFO_KHR = 2,
+- VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR,
+- VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_KHR,
+- VK_PRESENT_MODE_NUM = (VK_PRESENT_MODE_FIFO_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
+- VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
+-} VkPresentModeKHR;
+-
+-typedef enum {
+- VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0x00000000,
+- VK_COLORSPACE_NUM = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1),
+- VK_COLORSPACE_MAX_ENUM_KHR = 0x7FFFFFFF
+-} VkColorSpaceKHR;
+-
+-// ------------------------------------------------------------------------------------------------
+-// Flags
+-
+-// ------------------------------------------------------------------------------------------------
+-// Structures
+-
+-typedef struct {
+- uint32_t minImageCount; // Supported minimum number of images for the surface
+- uint32_t maxImageCount; // Supported maximum number of images for the surface, 0 for unlimited
+-
+- VkExtent2D currentExtent; // Current image width and height for the surface, (-1, -1) if undefined
+- VkExtent2D minImageExtent; // Supported minimum image width and height for the surface
+- VkExtent2D maxImageExtent; // Supported maximum image width and height for the surface
+-
+- VkSurfaceTransformFlagsKHR supportedTransforms;// 1 or more bits representing the transforms supported
+- VkSurfaceTransformKHR currentTransform; // The surface's current transform relative to the device's natural orientation
+-
+- uint32_t maxImageArraySize; // Supported maximum number of image layers for the surface
+-
+- VkImageUsageFlags supportedUsageFlags;// Supported image usage flags for the surface
+-} VkSurfacePropertiesKHR;
+-
+-typedef struct {
+- VkFormat format; // Supported pair of rendering format
+- VkColorSpaceKHR colorSpace; // and colorspace for the surface
+-} VkSurfaceFormatKHR;
+-
+-typedef struct {
+- VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
+- const void* pNext; // Pointer to next structure
+-
+- const VkSurfaceDescriptionKHR* pSurfaceDescription;// describes the swap chain's target surface
+-
+- uint32_t minImageCount; // Minimum number of presentation images the application needs
+- VkFormat imageFormat; // Format of the presentation images
+- VkColorSpaceKHR imageColorSpace; // Colorspace of the presentation images
+- VkExtent2D imageExtent; // Dimensions of the presentation images
+- VkImageUsageFlags imageUsageFlags; // Bits indicating how the presentation images will be used
+- VkSurfaceTransformKHR preTransform; // The transform, relative to the device's natural orientation, applied to the image content prior to presentation
+- uint32_t imageArraySize; // Determines the number of views for multiview/stereo presentation
+-
+- VkSharingMode sharingMode; // Sharing mode used for the presentation images
+- uint32_t queueFamilyCount; // Number of queue families having access to the images in case of concurrent sharing mode
+- const uint32_t* pQueueFamilyIndices; // Array of queue family indices having access to the images in case of concurrent sharing mode
+-
+- VkPresentModeKHR presentMode; // Which presentation mode to use for presents on this swap chain
+-
+- VkSwapchainKHR oldSwapchain; // Existing swap chain to replace, if any
+-
+- VkBool32 clipped; // Specifies whether presentable images may be affected by window clip regions
+-} VkSwapchainCreateInfoKHR;
+-
+-typedef struct {
+- VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
+- const void* pNext; // Pointer to next structure
+- uint32_t swapchainCount; // Number of swap chains to present in this call
+- const VkSwapchainKHR* swapchains; // Swap chains to present an image from
+- const uint32_t* imageIndices; // Indices of which swapchain images to present
+-} VkPresentInfoKHR;
+-
+-// ------------------------------------------------------------------------------------------------
+-// Function types
+-
+-typedef VkResult (VKAPI *PFN_vkGetSurfacePropertiesKHR)(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, VkSurfacePropertiesKHR* pSurfaceProperties);
+-typedef VkResult (VKAPI *PFN_vkGetSurfaceFormatsKHR)(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats);
+-typedef VkResult (VKAPI *PFN_vkGetSurfacePresentModesKHR)(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkPresentModeKHR* pPresentModes);
+-typedef VkResult (VKAPI *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain);
+-typedef VkResult (VKAPI *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain);
+-typedef VkResult (VKAPI *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pCount, VkImage* pSwapchainImages);
+-typedef VkResult (VKAPI *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, uint32_t* pImageIndex);
+-typedef VkResult (VKAPI *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo);
+-
+-// ------------------------------------------------------------------------------------------------
+-// Function prototypes
+-
+-#ifdef VK_PROTOTYPES
+-
+-VkResult VKAPI vkGetSurfacePropertiesKHR(
+- VkDevice device,
+- const VkSurfaceDescriptionKHR* pSurfaceDescription,
+- VkSurfacePropertiesKHR* pSurfaceProperties);
+-
+-VkResult VKAPI vkGetSurfaceFormatsKHR(
+- VkDevice device,
+- const VkSurfaceDescriptionKHR* pSurfaceDescription,
+- uint32_t* pCount,
+- VkSurfaceFormatKHR* pSurfaceFormats);
+-
+-VkResult VKAPI vkGetSurfacePresentModesKHR(
+- VkDevice device,
+- const VkSurfaceDescriptionKHR* pSurfaceDescription,
+- uint32_t* pCount,
+- VkPresentModeKHR* pPresentModes);
+-
+-VkResult VKAPI vkCreateSwapchainKHR(
+- VkDevice device,
+- const VkSwapchainCreateInfoKHR* pCreateInfo,
+- VkSwapchainKHR* pSwapchain);
+-
+-VkResult VKAPI vkDestroySwapchainKHR(
+- VkDevice device,
+- VkSwapchainKHR swapchain);
+-
+-VkResult VKAPI vkGetSwapchainImagesKHR(
+- VkDevice device,
+- VkSwapchainKHR swapchain,
+- uint32_t* pCount,
+- VkImage* pSwapchainImages);
+-
+-VkResult VKAPI vkAcquireNextImageKHR(
+- VkDevice device,
+- VkSwapchainKHR swapchain,
+- uint64_t timeout,
+- VkSemaphore semaphore,
+- uint32_t* pImageIndex);
+-
+-VkResult VKAPI vkQueuePresentKHR(
+- VkQueue queue,
+- VkPresentInfoKHR* pPresentInfo);
+-
+-#endif // VK_PROTOTYPES
+-
+-#ifdef __cplusplus
+-} // extern "C"
+-#endif // __cplusplus
+-
+-#endif // __VK_EXT_KHR_SWAPCHAIN_H__
+diff --git a/vulkan/include/vulkan/vk_ext_khr_swapchain.h b/vulkan/include/vulkan/vk_ext_khr_swapchain.h
+deleted file mode 100644
+index 862b4d5..0000000
+--- a/vulkan/include/vulkan/vk_ext_khr_swapchain.h
++++ /dev/null
+@@ -1,153 +0,0 @@
+-//
+-// File: vk_ext_khr_swapchain.h
+-//
+-/*
+-** Copyright (c) 2015 The Khronos Group Inc.
+-**
+-** Permission is hereby granted, free of charge, to any person obtaining a
+-** copy of this software and/or associated documentation files (the
+-** "Materials"), to deal in the Materials without restriction, including
+-** without limitation the rights to use, copy, modify, merge, publish,
+-** distribute, sublicense, and/or sell copies of the Materials, and to
+-** permit persons to whom the Materials are furnished to do so, subject to
+-** the following conditions:
+-**
+-** The above copyright notice and this permission notice shall be included
+-** in all copies or substantial portions of the Materials.
+-**
+-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+-*/
+-
+-#ifndef __VK_EXT_KHR_SWAPCHAIN_H__
+-#define __VK_EXT_KHR_SWAPCHAIN_H__
+-
+-#include "vulkan.h"
+-
+-#define VK_EXT_KHR_SWAPCHAIN_REVISION 17
+-#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 1
+-#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
+-
+-#ifdef __cplusplus
+-extern "C"
+-{
+-#endif // __cplusplus
+-
+-// ------------------------------------------------------------------------------------------------
+-// Objects
+-
+-// ------------------------------------------------------------------------------------------------
+-// Enumeration constants
+-
+-#define VK_EXT_KHR_SWAPCHAIN_ENUM(type,id) ((type)((int)0xc0000000 - VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER * -1024 + (id)))
+-#define VK_EXT_KHR_SWAPCHAIN_ENUM_POSITIVE(type,id) ((type)((int)0x40000000 + (VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER - 1) * 1024 + (id)))
+-
+-// Extend VkStructureType enum with extension specific constants
+-#define VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR VK_EXT_KHR_SWAPCHAIN_ENUM(VkStructureType, 0)
+-
+-// ------------------------------------------------------------------------------------------------
+-// Enumerations
+-
+-typedef enum {
+- VK_SURFACE_TRANSFORM_NONE_KHR = 0,
+- VK_SURFACE_TRANSFORM_ROT90_KHR = 1,
+- VK_SURFACE_TRANSFORM_ROT180_KHR = 2,
+- VK_SURFACE_TRANSFORM_ROT270_KHR = 3,
+- VK_SURFACE_TRANSFORM_HMIRROR_KHR = 4,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT90_KHR = 5,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT180_KHR = 6,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT270_KHR = 7,
+- VK_SURFACE_TRANSFORM_INHERIT_KHR = 8,
+-} VkSurfaceTransformKHR;
+-
+-typedef enum {
+- VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
+- VK_SURFACE_TRANSFORM_ROT90_BIT_KHR = 0x00000002,
+- VK_SURFACE_TRANSFORM_ROT180_BIT_KHR = 0x00000004,
+- VK_SURFACE_TRANSFORM_ROT270_BIT_KHR = 0x00000008,
+- VK_SURFACE_TRANSFORM_HMIRROR_BIT_KHR = 0x00000010,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT90_BIT_KHR = 0x00000020,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT180_BIT_KHR = 0x00000040,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT270_BIT_KHR = 0x00000080,
+- VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
+-} VkSurfaceTransformFlagBitsKHR;
+-typedef VkFlags VkSurfaceTransformFlagsKHR;
+-
+-typedef enum {
+- VK_PLATFORM_WIN32_KHR = 0,
+- VK_PLATFORM_X11_KHR = 1,
+- VK_PLATFORM_XCB_KHR = 2,
+- VK_PLATFORM_ANDROID_KHR = 3,
+- VK_PLATFORM_WAYLAND_KHR = 4,
+- VK_PLATFORM_MIR_KHR = 5,
+- VK_PLATFORM_BEGIN_RANGE_KHR = VK_PLATFORM_WIN32_KHR,
+- VK_PLATFORM_END_RANGE_KHR = VK_PLATFORM_MIR_KHR,
+- VK_PLATFORM_NUM_KHR = (VK_PLATFORM_MIR_KHR - VK_PLATFORM_WIN32_KHR + 1),
+- VK_PLATFORM_MAX_ENUM_KHR = 0x7FFFFFFF
+-} VkPlatformKHR;
+-
+-// ------------------------------------------------------------------------------------------------
+-// Flags
+-
+-// ------------------------------------------------------------------------------------------------
+-// Structures
+-
+-// Placeholder structure header for the different types of surface description structures
+-typedef struct {
+- VkStructureType sType; // Can be any of the VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_XXX_KHR constants
+- const void* pNext; // Pointer to next structure
+-} VkSurfaceDescriptionKHR;
+-
+-// Surface description structure for a native platform window surface
+-typedef struct {
+- VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR
+- const void* pNext; // Pointer to next structure
+- VkPlatformKHR platform; // e.g. VK_PLATFORM_*_KHR
+- void* pPlatformHandle;
+- void* pPlatformWindow;
+-} VkSurfaceDescriptionWindowKHR;
+-
+-// pPlatformHandle points to this struct when platform is VK_PLATFORM_X11_KHR
+-#ifdef _X11_XLIB_H_
+-typedef struct {
+- Display* dpy; // Display connection to an X server
+- Window root; // To identify the X screen
+-} VkPlatformHandleX11KHR;
+-#endif /* _X11_XLIB_H_ */
+-
+-// pPlatformHandle points to this struct when platform is VK_PLATFORM_XCB_KHR
+-#ifdef __XCB_H__
+-typedef struct {
+- xcb_connection_t* connection; // XCB connection to an X server
+- xcb_window_t root; // To identify the X screen
+-} VkPlatformHandleXcbKHR;
+-#endif /* __XCB_H__ */
+-
+-// ------------------------------------------------------------------------------------------------
+-// Function types
+-
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkSurfaceDescriptionKHR* pSurfaceDescription, VkBool32* pSupported);
+-
+-// ------------------------------------------------------------------------------------------------
+-// Function prototypes
+-
+-#ifdef VK_PROTOTYPES
+-
+-VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
+- VkPhysicalDevice physicalDevice,
+- uint32_t queueFamilyIndex,
+- const VkSurfaceDescriptionKHR* pSurfaceDescription,
+- VkBool32* pSupported);
+-
+-#endif // VK_PROTOTYPES
+-
+-#ifdef __cplusplus
+-} // extern "C"
+-#endif // __cplusplus
+-
+-#endif // __VK_EXT_KHR_SWAPCHAIN_H__
+diff --git a/vulkan/include/vulkan/vk_platform.h b/vulkan/include/vulkan/vk_platform.h
+index 969e532..14dc553 100644
+--- a/vulkan/include/vulkan/vk_platform.h
++++ b/vulkan/include/vulkan/vk_platform.h
+@@ -71,4 +71,32 @@ extern "C"
+ } // extern "C"
+ #endif // __cplusplus
+
++// Platform-specific headers required by platform window system extensions.
++// These are enabled prior to #including "vulkan.h". The same enable then
++// controls inclusion of the extension interfaces in vulkan.h.
++
++#ifdef VK_USE_PLATFORM_ANDROID_KHR
++#include <android/native_window.h>
++#endif
++
++#ifdef VK_USE_PLATFORM_MIR_KHR
++#include <mir_toolkit/client_types.h>
++#endif
++
++#ifdef VK_USE_PLATFORM_WAYLAND_KHR
++#include <wayland-client.h>
++#endif
++
++#ifdef VK_USE_PLATFORM_WIN32_KHR
++#include <windows.h>
++#endif
++
++#ifdef VK_USE_PLATFORM_X11_KHR
++#include <X11/Xlib.h>
++#endif
++
++#ifdef VK_USE_PLATFORM_XCB_KHR
++#include <xcb/xcb.h>
++#endif
++
+ #endif // __VK_PLATFORM_H__
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index d6eb918..ee921bf 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -3002,6 +3002,438 @@ void VKAPI vkCmdExecuteCommands(
+ const VkCmdBuffer* pCmdBuffers);
+ #endif
+
++#define vk_ext_khr_surface 1
++VK_DEFINE_NONDISP_HANDLE(VkSurfaceKHR)
++
++#define VK_EXT_KHR_SURFACE_REVISION 19
++#define VK_EXT_KHR_SURFACE_EXTENSION_NUMBER 1
++#define VK_EXT_KHR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_surface"
++
++typedef void (VKAPI *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface);
++typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface);
++
++#ifdef VK_PROTOTYPES
++void VKAPI vkDestroySurfaceKHR(
++ VkInstance instance,
++ VkSurfaceKHR surface);
++
++VkBool32 VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ uint32_t queueFamilyIndex,
++ VkSurfaceKHR surface);
++#endif
++
++#define vk_ext_khr_swapchain 1
++VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR)
++
++#define VK_EXT_KHR_SWAPCHAIN_REVISION 59
++#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
++#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
++#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
++#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801)
++#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR ((VkImageLayout)(int)0xc0000802)
++#define VK_SUBOPTIMAL_KHR ((VkResult)(int)0x40000403)
++#define VK_ERROR_OUT_OF_DATE_KHR ((VkResult)(int)0xc0000804)
++
++
++typedef enum {
++ VK_SURFACE_TRANSFORM_NONE_KHR = 0,
++ VK_SURFACE_TRANSFORM_ROT90_KHR = 1,
++ VK_SURFACE_TRANSFORM_ROT180_KHR = 2,
++ VK_SURFACE_TRANSFORM_ROT270_KHR = 3,
++ VK_SURFACE_TRANSFORM_HMIRROR_KHR = 4,
++ VK_SURFACE_TRANSFORM_HMIRROR_ROT90_KHR = 5,
++ VK_SURFACE_TRANSFORM_HMIRROR_ROT180_KHR = 6,
++ VK_SURFACE_TRANSFORM_HMIRROR_ROT270_KHR = 7,
++ VK_SURFACE_TRANSFORM_INHERIT_KHR = 8,
++ VK_SURFACE_TRANSFORM_BEGIN_RANGE = VK_SURFACE_TRANSFORM_NONE_KHR,
++ VK_SURFACE_TRANSFORM_END_RANGE = VK_SURFACE_TRANSFORM_INHERIT_KHR,
++ VK_SURFACE_TRANSFORM_NUM = (VK_SURFACE_TRANSFORM_INHERIT_KHR - VK_SURFACE_TRANSFORM_NONE_KHR + 1),
++ VK_SURFACE_TRANSFORM_MAX_ENUM = 0x7FFFFFFF
++} VkSurfaceTransformKHR;
++
++typedef enum {
++ VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0,
++ VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
++ VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
++ VK_COLORSPACE_NUM = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1),
++ VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF
++} VkColorSpaceKHR;
++
++typedef enum {
++ VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
++ VK_PRESENT_MODE_MAILBOX_KHR = 1,
++ VK_PRESENT_MODE_FIFO_KHR = 2,
++ VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR,
++ VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_KHR,
++ VK_PRESENT_MODE_NUM = (VK_PRESENT_MODE_FIFO_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
++ VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF
++} VkPresentModeKHR;
++
++
++typedef enum {
++ VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
++ VK_SURFACE_TRANSFORM_ROT90_BIT_KHR = 0x00000002,
++ VK_SURFACE_TRANSFORM_ROT180_BIT_KHR = 0x00000004,
++ VK_SURFACE_TRANSFORM_ROT270_BIT_KHR = 0x00000008,
++ VK_SURFACE_TRANSFORM_HMIRROR_BIT_KHR = 0x00000010,
++ VK_SURFACE_TRANSFORM_HMIRROR_ROT90_BIT_KHR = 0x00000020,
++ VK_SURFACE_TRANSFORM_HMIRROR_ROT180_BIT_KHR = 0x00000040,
++ VK_SURFACE_TRANSFORM_HMIRROR_ROT270_BIT_KHR = 0x00000080,
++ VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
++} VkSurfaceTransformFlagBitsKHR;
++typedef VkFlags VkSurfaceTransformFlagsKHR;
++
++typedef struct {
++ uint32_t minImageCount;
++ uint32_t maxImageCount;
++ VkExtent2D currentExtent;
++ VkExtent2D minImageExtent;
++ VkExtent2D maxImageExtent;
++ VkSurfaceTransformFlagsKHR supportedTransforms;
++ VkSurfaceTransformKHR currentTransform;
++ uint32_t maxImageArraySize;
++ VkImageUsageFlags supportedUsageFlags;
++} VkSurfacePropertiesKHR;
++
++typedef struct {
++ VkFormat format;
++ VkColorSpaceKHR colorSpace;
++} VkSurfaceFormatKHR;
++
++typedef struct {
++ VkStructureType sType;
++ const void* pNext;
++ VkSurfaceKHR surface;
++ uint32_t minImageCount;
++ VkFormat imageFormat;
++ VkColorSpaceKHR imageColorSpace;
++ VkExtent2D imageExtent;
++ VkImageUsageFlags imageUsageFlags;
++ VkSurfaceTransformKHR preTransform;
++ uint32_t imageArraySize;
++ VkSharingMode sharingMode;
++ uint32_t queueFamilyCount;
++ const uint32_t* pQueueFamilyIndices;
++ VkPresentModeKHR presentMode;
++ VkSwapchainKHR oldSwapchain;
++ VkBool32 clipped;
++} VkSwapchainCreateInfoKHR;
++
++typedef struct {
++ VkStructureType sType;
++ const void* pNext;
++ uint32_t swapchainCount;
++ const VkSwapchainKHR* swapchains;
++ const uint32_t* imageIndices;
++} VkPresentInfoKHR;
++
++
++typedef VkResult (VKAPI *PFN_vkGetSurfacePropertiesKHR)(VkDevice device, VkSurfaceKHR surface, VkSurfacePropertiesKHR* pSurfaceProperties);
++typedef VkResult (VKAPI *PFN_vkGetSurfaceFormatsKHR)(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats);
++typedef VkResult (VKAPI *PFN_vkGetSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkPresentModeKHR* pPresentModes);
++typedef VkResult (VKAPI *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain);
++typedef void (VKAPI *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain);
++typedef VkResult (VKAPI *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pCount, VkImage* pSwapchainImages);
++typedef VkResult (VKAPI *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
++typedef VkResult (VKAPI *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo);
++
++#ifdef VK_PROTOTYPES
++VkResult VKAPI vkGetSurfacePropertiesKHR(
++ VkDevice device,
++ VkSurfaceKHR surface,
++ VkSurfacePropertiesKHR* pSurfaceProperties);
++
++VkResult VKAPI vkGetSurfaceFormatsKHR(
++ VkDevice device,
++ VkSurfaceKHR surface,
++ uint32_t* pCount,
++ VkSurfaceFormatKHR* pSurfaceFormats);
++
++VkResult VKAPI vkGetSurfacePresentModesKHR(
++ VkDevice device,
++ VkSurfaceKHR surface,
++ uint32_t* pCount,
++ VkPresentModeKHR* pPresentModes);
++
++VkResult VKAPI vkCreateSwapchainKHR(
++ VkDevice device,
++ const VkSwapchainCreateInfoKHR* pCreateInfo,
++ VkSwapchainKHR* pSwapchain);
++
++void VKAPI vkDestroySwapchainKHR(
++ VkDevice device,
++ VkSwapchainKHR swapchain);
++
++VkResult VKAPI vkGetSwapchainImagesKHR(
++ VkDevice device,
++ VkSwapchainKHR swapchain,
++ uint32_t* pCount,
++ VkImage* pSwapchainImages);
++
++VkResult VKAPI vkAcquireNextImageKHR(
++ VkDevice device,
++ VkSwapchainKHR swapchain,
++ uint64_t timeout,
++ VkSemaphore semaphore,
++ VkFence fence,
++ uint32_t* pImageIndex);
++
++VkResult VKAPI vkQueuePresentKHR(
++ VkQueue queue,
++ VkPresentInfoKHR* pPresentInfo);
++#endif
++
++#define vk_ext_khr_display 1
++VK_DEFINE_NONDISP_HANDLE(VkDisplayKHR)
++VK_DEFINE_NONDISP_HANDLE(VkDisplayModeKHR)
++
++#define VK_EXT_KHR_DISPLAY_REVISION 16
++#define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 3
++#define VK_EXT_KHR_DISPLAY_EXTENSION_NAME "VK_EXT_KHR_display"
++#define VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c00)
++#define VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_DISPLAY_PLANE_KHR ((VkStructureType)(int)0xc0000c01)
++
++
++typedef enum {
++ VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000001,
++ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000002,
++ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000004,
++} VkDisplayPlaneAlphaFlagBitsKHR;
++typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
++
++typedef struct {
++ VkDisplayKHR display;
++ const char* displayName;
++ VkExtent2D physicalDimensions;
++ VkExtent2D physicalResolution;
++ VkSurfaceTransformFlagsKHR supportedTransforms;
++ uint32_t planeCount;
++ VkBool32 planeReorderPossible;
++} VkDisplayPropertiesKHR;
++
++typedef struct {
++ uint32_t pixelClock;
++ VkExtent2D visibleRegion;
++ VkExtent2D totalRegion;
++ VkExtent2D physicalDimensions;
++ uint32_t hSyncStart;
++ uint32_t hSyncEnd;
++ uint32_t vSyncStart;
++ uint32_t vSyncEnd;
++ VkBool32 interlaced;
++ VkBool32 doublescan;
++ VkBool32 hSyncPos;
++ VkBool32 vSyncPos;
++} VkDisplayTimingKHR;
++
++typedef struct {
++ VkDisplayModeKHR displayMode;
++ VkDisplayTimingKHR timing;
++} VkDisplayModePropertiesKHR;
++
++typedef struct {
++ VkStructureType sType;
++ const void* pNext;
++ VkDisplayTimingKHR timing;
++} VkDisplayModeCreateInfoKHR;
++
++typedef struct {
++ VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
++ VkOffset2D minSrcPosition;
++ VkOffset2D maxSrcPosition;
++ VkExtent2D minSrcExtent;
++ VkExtent2D maxSrcExtent;
++ VkOffset2D minDstPosition;
++ VkOffset2D maxDstPosition;
++ VkExtent2D minDstExtent;
++ VkExtent2D maxDstExtent;
++} VkDisplayPlanePropertiesKHR;
++
++typedef struct {
++ VkStructureType sType;
++ const void* pNext;
++ VkDisplayModeKHR displayMode;
++ uint32_t planeIndex;
++ uint32_t planeStackIndex;
++ VkSurfaceTransformKHR transform;
++ float globalAlpha;
++ VkDisplayPlaneAlphaFlagsKHR alphaMode;
++ VkExtent2D imageSize;
++} VkSurfaceDescriptionDisplayPlaneKHR;
++
++
++typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkDisplayPropertiesKHR* pProperties);
++typedef VkResult (VKAPI *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pCount, VkDisplayModePropertiesKHR* pModeProperties);
++typedef VkResult (VKAPI *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, VkDisplayModeKHR* pMode);
++typedef VkResult (VKAPI *PFN_vkGetDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlanePropertiesKHR* pProperties);
++
++#ifdef VK_PROTOTYPES
++VkResult VKAPI vkGetPhysicalDeviceDisplayPropertiesKHR(
++ VkPhysicalDevice physicalDevice,
++ uint32_t* pCount,
++ VkDisplayPropertiesKHR* pProperties);
++
++VkResult VKAPI vkGetDisplayModePropertiesKHR(
++ VkPhysicalDevice physicalDevice,
++ VkDisplayKHR display,
++ uint32_t* pCount,
++ VkDisplayModePropertiesKHR* pModeProperties);
++
++VkResult VKAPI vkCreateDisplayModeKHR(
++ VkPhysicalDevice physicalDevice,
++ VkDisplayKHR display,
++ const VkDisplayModeCreateInfoKHR* pCreateInfo,
++ VkDisplayModeKHR* pMode);
++
++VkResult VKAPI vkGetDisplayPlanePropertiesKHR(
++ VkPhysicalDevice physicalDevice,
++ VkDisplayKHR display,
++ VkDisplayModeKHR mode,
++ uint32_t planeIndex,
++ VkDisplayPlanePropertiesKHR* pProperties);
++#endif
++
++#define vk_ext_khr_display_swapchain 1
++#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_REVISION 4
++#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4
++#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_display_swapchain"
++#define VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0001000)
++#define VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0001001)
++#define VK_ERROR_INCOMPATIBLE_DISPLAY_KHR ((VkResult)(int)0xc0001002)
++
++typedef struct {
++ VkStructureType sType;
++ const void* pNext;
++ const VkSwapchainCreateInfoKHR* pNextSwapchainCreateInfo;
++} VkDisplaySwapchainCreateInfoKHR;
++
++typedef struct {
++ VkStructureType sType;
++ const void* pNext;
++ VkRect2D srcRect;
++ VkRect2D dstRect;
++} VkDisplayPresentInfoKHR;
++
++
++
++#define vk_ext_khr_x11_surface 1
++#ifdef VK_USE_PLATFORM_X11_KHR
++#include <X11/Xlib.h>
++
++#define VK_EXT_KHR_X11_SURFACE_REVISION 1
++#define VK_EXT_KHR_X11_SURFACE_EXTENSION_NUMBER 5
++#define VK_EXT_KHR_X11_SURFACE_EXTENSION_NAME "VK_EXT_KHR_x11_surface"
++
++typedef VkResult (VKAPI *PFN_vkCreateX11SurfaceKHR)(VkInstance instance, Display* dpy, Window root, Window window, VkSurfaceKHR* pSurface);
++
++#ifdef VK_PROTOTYPES
++VkResult VKAPI vkCreateX11SurfaceKHR(
++ VkInstance instance,
++ Display* dpy,
++ Window root,
++ Window window,
++ VkSurfaceKHR* pSurface);
++#endif
++#endif /* VK_USE_PLATFORM_X11_KHR */
++
++#define vk_ext_khr_xcb_surface 1
++#ifdef VK_USE_PLATFORM_XCB_KHR
++#include <xcb/xcb.h>
++
++#define VK_EXT_KHR_XCB_SURFACE_REVISION 1
++#define VK_EXT_KHR_XCB_SURFACE_EXTENSION_NUMBER 6
++#define VK_EXT_KHR_XCB_SURFACE_EXTENSION_NAME "VK_EXT_KHR_xcb_surface"
++
++typedef VkResult (VKAPI *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, xcb_connection_t* connection, xcb_window_t root, xcb_window_t window, VkSurfaceKHR* pSurface);
++
++#ifdef VK_PROTOTYPES
++VkResult VKAPI vkCreateXcbSurfaceKHR(
++ VkInstance instance,
++ xcb_connection_t* connection,
++ xcb_window_t root,
++ xcb_window_t window,
++ VkSurfaceKHR* pSurface);
++#endif
++#endif /* VK_USE_PLATFORM_XCB_KHR */
++
++#define vk_ext_khr_wayland_surface 1
++#ifdef VK_USE_PLATFORM_WAYLAND_KHR
++#include <wayland-client.h>
++
++#define VK_EXT_KHR_WAYLAND_SURFACE_REVISION 1
++#define VK_EXT_KHR_WAYLAND_SURFACE_EXTENSION_NUMBER 7
++#define VK_EXT_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_EXT_KHR_wayland_surface"
++
++typedef VkResult (VKAPI *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, struct wl_display* display, struct wl_surface* surface, VkSurfaceKHR* pSurface);
++
++#ifdef VK_PROTOTYPES
++VkResult VKAPI vkCreateWaylandSurfaceKHR(
++ VkInstance instance,
++ struct wl_display* display,
++ struct wl_surface* surface,
++ VkSurfaceKHR* pSurface);
++#endif
++#endif /* VK_USE_PLATFORM_WAYLAND_KHR */
++
++#define vk_ext_khr_mir_surface 1
++#ifdef VK_USE_PLATFORM_MIR_KHR
++#include <mir_toolkit/client_types.h>
++
++#define VK_EXT_KHR_MIR_SURFACE_REVISION 1
++#define VK_EXT_KHR_MIR_SURFACE_EXTENSION_NUMBER 8
++#define VK_EXT_KHR_MIR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_mir_surface"
++
++typedef VkResult (VKAPI *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, MirConnection* connection, MirSurface* mirSurface, VkSurfaceKHR* pSurface);
++
++#ifdef VK_PROTOTYPES
++VkResult VKAPI vkCreateMirSurfaceKHR(
++ VkInstance instance,
++ MirConnection* connection,
++ MirSurface* mirSurface,
++ VkSurfaceKHR* pSurface);
++#endif
++#endif /* VK_USE_PLATFORM_MIR_KHR */
++
++#define vk_ext_khr_android_surface 1
++#ifdef VK_USE_PLATFORM_ANDROID_KHR
++#include <android/native_window.h>
++
++#define VK_EXT_KHR_ANDROID_SURFACE_REVISION 1
++#define VK_EXT_KHR_ANDROID_SURFACE_EXTENSION_NUMBER 9
++#define VK_EXT_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_EXT_KHR_android_surface"
++#define VK_ERROR_INVALID_ANDROID_WINDOW_KHR ((VkResult)(int)0xc0002400)
++#define VK_ERROR_ANDROID_WINDOW_IN_USE_KHR ((VkResult)(int)0xc0002401)
++
++typedef VkResult (VKAPI *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, ANativeWindow* window, VkSurfaceKHR* pSurface);
++
++#ifdef VK_PROTOTYPES
++VkResult VKAPI vkCreateAndroidSurfaceKHR(
++ VkInstance instance,
++ ANativeWindow* window,
++ VkSurfaceKHR* pSurface);
++#endif
++#endif /* VK_USE_PLATFORM_ANDROID_KHR */
++
++#define vk_ext_khr_win32_surface 1
++#ifdef VK_USE_PLATFORM_WIN32_KHR
++#include <windows.h>
++
++#define VK_EXT_KHR_WIN32_SURFACE_REVISION 1
++#define VK_EXT_KHR_WIN32_SURFACE_EXTENSION_NUMBER 10
++#define VK_EXT_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_EXT_KHR_win32_surface"
++
++typedef VkResult (VKAPI *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, HINSTANCE hinstance, HWND hwnd, VkSurfaceKHR* pSurface);
++
++#ifdef VK_PROTOTYPES
++VkResult VKAPI vkCreateWin32SurfaceKHR(
++ VkInstance instance,
++ HINSTANCE hinstance,
++ HWND hwnd,
++ VkSurfaceKHR* pSurface);
++#endif
++#endif /* VK_USE_PLATFORM_WIN32_KHR */
++
+ #ifdef __cplusplus
+ }
+ #endif
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 0af3bc8..339101f 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -762,23 +762,28 @@ void vkCmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkSurfaceDescriptionKHR* pSurfaceDescription, VkBool32* pSupported) {
+- return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, pSurfaceDescription, pSupported);
++void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface) {
++ GetVtbl(instance).DestroySurfaceKHR(instance, surface);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetSurfacePropertiesKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, VkSurfacePropertiesKHR* pSurfaceProperties) {
+- return GetVtbl(device).GetSurfacePropertiesKHR(device, pSurfaceDescription, pSurfaceProperties);
++VkBool32 vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface) {
++ return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetSurfaceFormatsKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats) {
+- return GetVtbl(device).GetSurfaceFormatsKHR(device, pSurfaceDescription, pCount, pSurfaceFormats);
++VkResult vkGetSurfacePropertiesKHR(VkDevice device, VkSurfaceKHR surface, VkSurfacePropertiesKHR* pSurfaceProperties) {
++ return GetVtbl(device).GetSurfacePropertiesKHR(device, surface, pSurfaceProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetSurfacePresentModesKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkPresentModeKHR* pPresentModes) {
+- return GetVtbl(device).GetSurfacePresentModesKHR(device, pSurfaceDescription, pCount, pPresentModes);
++VkResult vkGetSurfaceFormatsKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats) {
++ return GetVtbl(device).GetSurfaceFormatsKHR(device, surface, pCount, pSurfaceFormats);
++}
++
++__attribute__((visibility("default")))
++VkResult vkGetSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkPresentModeKHR* pPresentModes) {
++ return GetVtbl(device).GetSurfacePresentModesKHR(device, surface, pCount, pPresentModes);
+ }
+
+ __attribute__((visibility("default")))
+@@ -787,8 +792,8 @@ VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* p
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain) {
+- return GetVtbl(device).DestroySwapchainKHR(device, swapchain);
++void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain) {
++ GetVtbl(device).DestroySwapchainKHR(device, swapchain);
+ }
+
+ __attribute__((visibility("default")))
+@@ -797,11 +802,16 @@ VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, uint32_t* pImageIndex) {
+- return GetVtbl(device).AcquireNextImageKHR(device, swapchain, timeout, semaphore, pImageIndex);
++VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
++ return GetVtbl(device).AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
+ }
+
+ __attribute__((visibility("default")))
+ VkResult vkQueuePresentKHR(VkQueue queue, VkPresentInfoKHR* pPresentInfo) {
+ return GetVtbl(queue).QueuePresentKHR(queue, pPresentInfo);
+ }
++
++__attribute__((visibility("default")))
++VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, struct ANativeWindow* window, VkSurfaceKHR* pSurface) {
++ return GetVtbl(instance).CreateAndroidSurfaceKHR(instance, window, pSurface);
++}
+diff --git a/vulkan/libvulkan/entry.cpp.tmpl b/vulkan/libvulkan/entry.cpp.tmpl
+index 72185e7..d0e665f 100644
+--- a/vulkan/libvulkan/entry.cpp.tmpl
++++ b/vulkan/libvulkan/entry.cpp.tmpl
+@@ -69,7 +69,7 @@ namespace {
+ } // namespace
+ ¶
+ {{range $f := AllCommands $}}
+- {{if not (GetAnnotation $f "pfn")}}
++ {{if and (not (GetAnnotation $f "pfn")) (Macro "IsExportedEntry" $f)}}
+ __attribute__((visibility("default")))
+ {{if eq (Macro "IsSpecialEntry" $f.Name) "true"}}
+ {{Macro "EmitSpecialEntry" $f}}
+@@ -84,6 +84,25 @@ namespace {
+
+ {{/*
+ -------------------------------------------------------------------------------
++ Decides whether an entrypoint should be exported from the Android Vulkan
++ library. Entrypoints in the core API and in mandatory extensions are
++ exported.
++-------------------------------------------------------------------------------
++*/}}
++{{define "IsExportedEntry"}}
++ {{AssertType $ "Function"}}
++ {{$ext := GetAnnotation $ "extension"}}
++ {{if $ext}}
++ {{$extval := index $ext.Arguments 0}}
++ {{if eq $extval "VK_EXT_KHR_surface"}}true
++ {{else if eq $extval "VK_EXT_KHR_swapchain"}}true
++ {{else if eq $extval "VK_EXT_KHR_android_surface"}}true{{end}}
++ {{else}}true{{end}}
++{{end}}
++
++
++{{/*
++-------------------------------------------------------------------------------
+ Decides whether an entrypoint needs special-case handling. Emits the string
+ "true" if so, nothing otherwise.
+ -------------------------------------------------------------------------------
+@@ -95,6 +114,7 @@ namespace {
+ {{end}}
+ {{end}}
+
++
+ {{/*
+ -------------------------------------------------------------------------------
+ Emits the entrypoint definition for the specified command, which always
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
+index b9bd689..f1ad5f3 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp
++++ b/vulkan/libvulkan/get_proc_addr.cpp
+@@ -49,8 +49,10 @@ const TEntry* FindProcEntry(const TEntry (&table)[N], const char* name) {
+
+ const NameProcEntry kInstanceProcTbl[] = {
+ // clang-format off
++ {"vkCreateAndroidSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateAndroidSurfaceKHR)},
+ {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDevice)},
+ {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyInstance)},
++ {"vkDestroySurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySurfaceKHR)},
+ {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateDeviceExtensionProperties)},
+ {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateDeviceLayerProperties)},
+ {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDevices)},
+@@ -209,8 +211,10 @@ const NameProcEntry kDeviceProcTbl[] = {
+
+ const NameOffsetEntry kInstanceOffsetTbl[] = {
+ // clang-format off
++ {"vkCreateAndroidSurfaceKHR", offsetof(InstanceVtbl, CreateAndroidSurfaceKHR)},
+ {"vkCreateDevice", offsetof(InstanceVtbl, CreateDevice)},
+ {"vkDestroyInstance", offsetof(InstanceVtbl, DestroyInstance)},
++ {"vkDestroySurfaceKHR", offsetof(InstanceVtbl, DestroySurfaceKHR)},
+ {"vkEnumerateDeviceExtensionProperties", offsetof(InstanceVtbl, EnumerateDeviceExtensionProperties)},
+ {"vkEnumerateDeviceLayerProperties", offsetof(InstanceVtbl, EnumerateDeviceLayerProperties)},
+ {"vkEnumeratePhysicalDevices", offsetof(InstanceVtbl, EnumeratePhysicalDevices)},
+@@ -490,7 +494,9 @@ bool LoadInstanceVtbl(VkInstance instance,
+ ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSparseImageFormatProperties");
+ success = false;
+ }
++ vtbl.DestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(get_proc_addr(instance, "vkDestroySurfaceKHR"));
+ vtbl.GetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"));
++ vtbl.CreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(get_proc_addr(instance, "vkCreateAndroidSurfaceKHR"));
+ // clang-format on
+ return success;
+ }
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp.tmpl b/vulkan/libvulkan/get_proc_addr.cpp.tmpl
+index 6d5f618..c6ec0d1 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp.tmpl
++++ b/vulkan/libvulkan/get_proc_addr.cpp.tmpl
+@@ -78,7 +78,7 @@ const TEntry* FindProcEntry(const TEntry (&table)[N], const char* name) {
+ const NameProcEntry kInstanceProcTbl[] = {«
+ // clang-format off
+ {{range $f := SortBy (AllCommands $) "FunctionName"}}
+- {{if eq (Macro "Vtbl" $f) "Instance"}}
++ {{if and (Macro "IsDispatched" $f) (eq (Macro "Vtbl" $f) "Instance")}}
+ {"{{Macro "FunctionName" $f}}", reinterpret_cast<PFN_vkVoidFunction>({{Macro "FunctionName" $f}})},
+ {{end}}
+ {{end}}
+@@ -88,7 +88,7 @@ const NameProcEntry kInstanceProcTbl[] = {«
+ const NameProcEntry kDeviceProcTbl[] = {«
+ // clang-format off
+ {{range $f := SortBy (AllCommands $) "FunctionName"}}
+- {{if eq (Macro "Vtbl" $f) "Device"}}
++ {{if and (Macro "IsDispatched" $f) (eq (Macro "Vtbl" $f) "Device")}}
+ {"{{Macro "FunctionName" $f}}", reinterpret_cast<PFN_vkVoidFunction>({{Macro "FunctionName" $f}})},
+ {{end}}
+ {{end}}
+@@ -98,7 +98,7 @@ const NameProcEntry kDeviceProcTbl[] = {«
+ const NameOffsetEntry kInstanceOffsetTbl[] = {«
+ // clang-format off
+ {{range $f := SortBy (AllCommands $) "FunctionName"}}
+- {{if eq (Macro "Vtbl" $f) "Instance"}}
++ {{if and (Macro "IsDispatched" $f) (eq (Macro "Vtbl" $f) "Instance")}}
+ {"{{Macro "FunctionName" $f}}", offsetof(InstanceVtbl, {{TrimPrefix "vk" (Macro "FunctionName" $f)}})},
+ {{end}}
+ {{end}}
+@@ -108,7 +108,7 @@ const NameOffsetEntry kInstanceOffsetTbl[] = {«
+ const NameOffsetEntry kDeviceOffsetTbl[] = {«
+ // clang-format off
+ {{range $f := SortBy (AllCommands $) "FunctionName"}}
+- {{if eq (Macro "Vtbl" $f) "Device"}}
++ {{if and (Macro "IsDispatched" $f) (eq (Macro "Vtbl" $f) "Device")}}
+ {"{{Macro "FunctionName" $f}}", offsetof(DeviceVtbl, {{TrimPrefix "vk" (Macro "FunctionName" $f)}})},
+ {{end}}
+ {{end}}
+@@ -194,7 +194,7 @@ bool LoadInstanceVtbl(VkInstance instance,
+ {{end}}
+ {{range $f := AllCommands $}}
+ {{if eq (Macro "Vtbl" $f) "Instance"}}
+- {{if (GetAnnotation $f "extension")}}
++ {{if and (GetAnnotation $f "extension") (Macro "IsDispatched" $f)}}
+ vtbl.{{TrimPrefix "vk" (Macro "FunctionName" $f)}} = §
+ reinterpret_cast<{{Macro "FunctionPtrName" $f}}>(§
+ get_proc_addr(instance, "{{Macro "FunctionName" $f}}"));
+@@ -265,3 +265,32 @@ bool LoadDeviceVtbl(VkDevice device,
+ } // namespace vulkan
+ ¶
+ {{end}}
++
++
++{{/*
++-------------------------------------------------------------------------------
++ This function emits nil for extension entrypoints that should not be
++ included in dispatch tables, "true" otherwise. Extensions that are ony used
++ directly between the loader and driver, or that aren't supported on Android
++ at all, should be excluded from dispatch.
++-------------------------------------------------------------------------------
++*/}}
++{{define "IsUnsupportedExtension"}}
++ {{$ext := index $.Arguments 0}}
++ {{ if eq $ext "VK_EXT_KHR_display"}}true
++ {{else if eq $ext "VK_EXT_KHR_display_swapchain"}}true
++ {{else if eq $ext "VK_EXT_KHR_x11_surface"}}true
++ {{else if eq $ext "VK_EXT_KHR_xcb_surface"}}true
++ {{else if eq $ext "VK_EXT_KHR_wayland_surface"}}true
++ {{else if eq $ext "VK_EXT_KHR_mir_surface"}}true
++ {{else if eq $ext "VK_EXT_KHR_win32_surface"}}true
++ {{end}}
++{{end}}
++
++{{define "IsDispatched"}}
++ {{AssertType $ "Function"}}
++ {{$ext := GetAnnotation $ "extension"}}
++ {{if not $ext}}true
++ {{else if not (Macro "IsUnsupportedExtension" $ext)}}true
++ {{end}}
++{{end}}
+diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
+index c427918..a44026f 100644
+--- a/vulkan/libvulkan/loader.cpp
++++ b/vulkan/libvulkan/loader.cpp
+@@ -1102,16 +1102,29 @@ VkResult DestroyDevice(VkDevice drv_device) {
+ return VK_SUCCESS;
+ }
+
+-void* AllocDeviceMem(VkDevice device,
+- size_t size,
+- size_t align,
+- VkSystemAllocType type) {
++void* AllocMem(VkInstance instance,
++ size_t size,
++ size_t align,
++ VkSystemAllocType type) {
++ const VkAllocCallbacks* alloc_cb = instance->alloc;
++ return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, type);
++}
++
++void FreeMem(VkInstance instance, void* ptr) {
++ const VkAllocCallbacks* alloc_cb = instance->alloc;
++ alloc_cb->pfnFree(alloc_cb->pUserData, ptr);
++}
++
++void* AllocMem(VkDevice device,
++ size_t size,
++ size_t align,
++ VkSystemAllocType type) {
+ const VkAllocCallbacks* alloc_cb =
+ static_cast<Device*>(GetVtbl(device)->device)->instance->alloc;
+ return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, type);
+ }
+
+-void FreeDeviceMem(VkDevice device, void* ptr) {
++void FreeMem(VkDevice device, void* ptr) {
+ const VkAllocCallbacks* alloc_cb =
+ static_cast<Device*>(GetVtbl(device)->device)->instance->alloc;
+ alloc_cb->pfnFree(alloc_cb->pUserData, ptr);
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index 5e0a6c9..3e34e75 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -18,9 +18,8 @@
+ #define LIBVULKAN_LOADER_H 1
+
+ #define VK_PROTOTYPES
++#define VK_USE_PLATFORM_ANDROID_KHR
+ #include <vulkan/vulkan.h>
+-#include <vulkan/vk_ext_khr_swapchain.h>
+-#include <vulkan/vk_ext_khr_device_swapchain.h>
+ #include <vulkan/vk_ext_android_native_buffer.h>
+
+ namespace vulkan {
+@@ -52,6 +51,8 @@ struct InstanceVtbl {
+ PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
+
+ // Layers and loader only, not implemented by drivers
++ PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
++ PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
+ PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
+ // clang-format on
+ };
+@@ -230,11 +231,16 @@ VkResult AllocCommandBuffers(VkDevice device,
+ VkCmdBuffer* cmdbuffers);
+ VkResult DestroyDevice(VkDevice drv_device);
+
+-void* AllocDeviceMem(VkDevice device,
+- size_t size,
+- size_t align,
+- VkSystemAllocType type);
+-void FreeDeviceMem(VkDevice device, void* ptr);
++void* AllocMem(VkInstance instance,
++ size_t size,
++ size_t align,
++ VkSystemAllocType type);
++void FreeMem(VkInstance instance, void* ptr);
++void* AllocMem(VkDevice device,
++ size_t size,
++ size_t align,
++ VkSystemAllocType type);
++void FreeMem(VkDevice device, void* ptr);
+ const DeviceVtbl& GetDriverVtbl(VkDevice device);
+ const DeviceVtbl& GetDriverVtbl(VkQueue queue);
+
+@@ -260,20 +266,22 @@ bool LoadDeviceVtbl(VkDevice device,
+ // -----------------------------------------------------------------------------
+ // swapchain.cpp
+
+-VkResult GetPhysicalDeviceSurfaceSupportKHR(
+- VkPhysicalDevice pdev,
+- uint32_t queue_family,
+- const VkSurfaceDescriptionKHR* surface_desc,
+- VkBool32* supported);
++VkResult CreateAndroidSurfaceKHR(VkInstance instance,
++ ANativeWindow* window,
++ VkSurfaceKHR* surface);
++void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface);
++VkBool32 GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev,
++ uint32_t queue_family,
++ VkSurfaceKHR surface);
+ VkResult GetSurfacePropertiesKHR(VkDevice device,
+- const VkSurfaceDescriptionKHR* surface_desc,
++ VkSurfaceKHR surface,
+ VkSurfacePropertiesKHR* properties);
+ VkResult GetSurfaceFormatsKHR(VkDevice device,
+- const VkSurfaceDescriptionKHR* surface_desc,
++ VkSurfaceKHR surface,
+ uint32_t* count,
+ VkSurfaceFormatKHR* formats);
+ VkResult GetSurfacePresentModesKHR(VkDevice device,
+- const VkSurfaceDescriptionKHR* surface_desc,
++ VkSurfaceKHR surface,
+ uint32_t* count,
+ VkPresentModeKHR* modes);
+ VkResult CreateSwapchainKHR(VkDevice device,
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index 70c0e33..6813680 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -49,43 +49,55 @@ struct NativeBaseDeleter {
+ void operator()(T* obj) { obj->common.decRef(&obj->common); }
+ };
+
+-template <typename T>
++template <typename T, typename Host>
+ class VulkanAllocator {
+ public:
+ typedef T value_type;
+
+- explicit VulkanAllocator(VkDevice device) : device_(device) {}
++ explicit VulkanAllocator(Host host) : host_(host) {}
+
+ template <typename U>
+- explicit VulkanAllocator(const VulkanAllocator<U>& other)
+- : device_(other.device_) {}
++ explicit VulkanAllocator(const VulkanAllocator<U, Host>& other)
++ : host_(other.host_) {}
+
+ T* allocate(size_t n) const {
+- return static_cast<T*>(AllocDeviceMem(
+- device_, n * sizeof(T), alignof(T), VK_SYSTEM_ALLOC_TYPE_INTERNAL));
++ return static_cast<T*>(AllocMem(host_, n * sizeof(T), alignof(T),
++ VK_SYSTEM_ALLOC_TYPE_INTERNAL));
+ }
+- void deallocate(T* p, size_t) const { return FreeDeviceMem(device_, p); }
++ void deallocate(T* p, size_t) const { return FreeMem(host_, p); }
+
+ private:
+- template <typename U>
++ template <typename U, typename H>
+ friend class VulkanAllocator;
+- VkDevice device_;
++ Host host_;
+ };
+
+-template <typename T>
+-std::shared_ptr<T> InitSharedPtr(VkDevice device, T* obj) {
++template <typename T, typename Host>
++std::shared_ptr<T> InitSharedPtr(Host host, T* obj) {
+ obj->common.incRef(&obj->common);
+ return std::shared_ptr<T>(obj, NativeBaseDeleter<T>(),
+- VulkanAllocator<T>(device));
++ VulkanAllocator<T, Host>(host));
+ }
+
+ // ----------------------------------------------------------------------------
+
++struct Surface {
++ std::shared_ptr<ANativeWindow> window;
++};
++
++VkSurfaceKHR HandleFromSurface(Surface* surface) {
++ return VkSurfaceKHR(reinterpret_cast<uint64_t>(surface));
++}
++
++Surface* SurfaceFromHandle(VkSurfaceKHR handle) {
++ return reinterpret_cast<Surface*>(handle.handle);
++}
++
+ struct Swapchain {
+- Swapchain(std::shared_ptr<ANativeWindow> window_, uint32_t num_images_)
+- : window(window_), num_images(num_images_) {}
++ Swapchain(Surface& surface_, uint32_t num_images_)
++ : surface(surface_), num_images(num_images_) {}
+
+- std::shared_ptr<ANativeWindow> window;
++ Surface& surface;
+ uint32_t num_images;
+
+ struct Image {
+@@ -113,95 +125,69 @@ Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
+
+ namespace vulkan {
+
+-VkResult GetPhysicalDeviceSurfaceSupportKHR(
+- VkPhysicalDevice /*pdev*/,
+- uint32_t /*queue_family*/,
+- const VkSurfaceDescriptionKHR* surface_desc,
+- VkBool32* supported) {
+-// TODO(jessehall): Fix the header, preferrably upstream, so values added to
+-// existing enums don't trigger warnings like this.
+-#pragma clang diagnostic push
+-#pragma clang diagnostic ignored "-Wold-style-cast"
+-#pragma clang diagnostic ignored "-Wsign-conversion"
+- ALOGE_IF(
+- surface_desc->sType != VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR,
+- "vkGetPhysicalDeviceSurfaceSupportKHR: pSurfaceDescription->sType=%#x "
+- "not supported",
+- surface_desc->sType);
+-#pragma clang diagnostic pop
++VkResult CreateAndroidSurfaceKHR(VkInstance instance,
++ ANativeWindow* window,
++ VkSurfaceKHR* out_surface) {
++ void* mem = AllocMem(instance, sizeof(Surface), alignof(Surface),
++ VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
++ if (!mem)
++ return VK_ERROR_OUT_OF_HOST_MEMORY;
++ Surface* surface = new (mem) Surface;
+
+- const VkSurfaceDescriptionWindowKHR* window_desc =
+- reinterpret_cast<const VkSurfaceDescriptionWindowKHR*>(surface_desc);
++ surface->window = InitSharedPtr(instance, window);
+
+- // TODO(jessehall): Also check whether the physical device exports the
+- // VK_EXT_ANDROID_native_buffer extension. For now, assume it does.
+- *supported = (window_desc->platform == VK_PLATFORM_ANDROID_KHR &&
+- !window_desc->pPlatformHandle &&
+- static_cast<ANativeWindow*>(window_desc->pPlatformWindow)
+- ->common.magic == ANDROID_NATIVE_WINDOW_MAGIC);
++ // TODO(jessehall): Create and use NATIVE_WINDOW_API_VULKAN.
++ int err =
++ native_window_api_connect(surface->window.get(), NATIVE_WINDOW_API_EGL);
++ if (err != 0) {
++ // TODO(jessehall): Improve error reporting. Can we enumerate possible
++ // errors and translate them to valid Vulkan result codes?
++ ALOGE("native_window_api_connect() failed: %s (%d)", strerror(-err),
++ err);
++ surface->~Surface();
++ FreeMem(instance, surface);
++ return VK_ERROR_INITIALIZATION_FAILED;
++ }
+
++ *out_surface = HandleFromSurface(surface);
+ return VK_SUCCESS;
+ }
+
++void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface_handle) {
++ Surface* surface = SurfaceFromHandle(surface_handle);
++ if (!surface)
++ return;
++ native_window_api_disconnect(surface->window.get(), NATIVE_WINDOW_API_EGL);
++ surface->~Surface();
++ FreeMem(instance, surface);
++}
++
++VkBool32 GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
++ uint32_t /*queue_family*/,
++ VkSurfaceKHR /*surface*/) {
++ return VK_TRUE;
++}
++
+ VkResult GetSurfacePropertiesKHR(VkDevice /*device*/,
+- const VkSurfaceDescriptionKHR* surface_desc,
++ VkSurfaceKHR surface,
+ VkSurfacePropertiesKHR* properties) {
+- const VkSurfaceDescriptionWindowKHR* window_desc =
+- reinterpret_cast<const VkSurfaceDescriptionWindowKHR*>(surface_desc);
+- ANativeWindow* window =
+- static_cast<ANativeWindow*>(window_desc->pPlatformWindow);
+-
+ int err;
+-
+- // TODO(jessehall): Currently the window must be connected for several
+- // queries -- including default dimensions -- to work, since Surface caches
+- // the queried values at connect() and queueBuffer(), and query() returns
+- // those cached values.
+- //
+- // The proposed refactoring to create a VkSurface object (bug 14596) will
+- // give us a place to connect once per window. If that doesn't end up
+- // happening, we'll probably need to maintain an internal list of windows
+- // that have swapchains created for them, search that list here, and
+- // only temporarily connect if the window doesn't have a swapchain.
+-
+- bool disconnect = true;
+- err = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
+- if (err == -EINVAL) {
+- // This is returned if the window is already connected, among other
+- // things. We'll just assume we're already connected and charge ahead.
+- // See TODO above, this is not cool.
+- ALOGW(
+- "vkGetSurfacePropertiesKHR: native_window_api_connect returned "
+- "-EINVAL, assuming already connected");
+- err = 0;
+- disconnect = false;
+- } else if (err != 0) {
+- // TODO(jessehall): Improve error reporting. Can we enumerate possible
+- // errors and translate them to valid Vulkan result codes?
+- return VK_ERROR_INITIALIZATION_FAILED;
+- }
++ ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
+
+ int width, height;
+ err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
+ if (err != 0) {
+ ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
+ strerror(-err), err);
+- if (disconnect)
+- native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+ err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
+ if (err != 0) {
+ ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
+ strerror(-err), err);
+- if (disconnect)
+- native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+- if (disconnect)
+- native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
+-
+ properties->currentExtent = VkExtent2D{width, height};
+
+ // TODO(jessehall): Figure out what the min/max values should be.
+@@ -238,13 +224,14 @@ VkResult GetSurfacePropertiesKHR(VkDevice /*device*/,
+ }
+
+ VkResult GetSurfaceFormatsKHR(VkDevice /*device*/,
+- const VkSurfaceDescriptionKHR* /*surface_desc*/,
++ VkSurfaceKHR /*surface*/,
+ uint32_t* count,
+ VkSurfaceFormatKHR* formats) {
+- // TODO(jessehall): Fill out the set of supported formats. Open question
+- // whether we should query the driver for support -- how does it know what
+- // the consumer can support? Should we support formats that don't
+- // correspond to gralloc formats?
++ // TODO(jessehall): Fill out the set of supported formats. Longer term, add
++ // a new gralloc method to query whether a (format, usage) pair is
++ // supported, and check that for each gralloc format that corresponds to a
++ // Vulkan format. Shorter term, just add a few more formats to the ones
++ // hardcoded below.
+
+ const VkSurfaceFormatKHR kFormats[] = {
+ {VK_FORMAT_R8G8B8A8_UNORM, VK_COLORSPACE_SRGB_NONLINEAR_KHR},
+@@ -262,11 +249,10 @@ VkResult GetSurfaceFormatsKHR(VkDevice /*device*/,
+ return result;
+ }
+
+-VkResult GetSurfacePresentModesKHR(
+- VkDevice /*device*/,
+- const VkSurfaceDescriptionKHR* /*surface_desc*/,
+- uint32_t* count,
+- VkPresentModeKHR* modes) {
++VkResult GetSurfacePresentModesKHR(VkDevice /*device*/,
++ VkSurfaceKHR /*surface*/,
++ uint32_t* count,
++ VkPresentModeKHR* modes) {
+ const VkPresentModeKHR kModes[] = {
+ VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR,
+ };
+@@ -304,26 +290,11 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ "present modes other than FIFO are not yet implemented");
+
+ // -- Configure the native window --
+- // Failure paths from here on need to disconnect the window.
+
++ Surface& surface = *SurfaceFromHandle(create_info->surface);
+ const DeviceVtbl& driver_vtbl = GetDriverVtbl(device);
+
+- std::shared_ptr<ANativeWindow> window = InitSharedPtr(
+- device, static_cast<ANativeWindow*>(
+- reinterpret_cast<const VkSurfaceDescriptionWindowKHR*>(
+- create_info->pSurfaceDescription)->pPlatformWindow));
+-
+- // TODO(jessehall): Create and use NATIVE_WINDOW_API_VULKAN.
+- err = native_window_api_connect(window.get(), NATIVE_WINDOW_API_EGL);
+- if (err != 0) {
+- // TODO(jessehall): Improve error reporting. Can we enumerate possible
+- // errors and translate them to valid Vulkan result codes?
+- ALOGE("native_window_api_connect() failed: %s (%d)", strerror(-err),
+- err);
+- return VK_ERROR_INITIALIZATION_FAILED;
+- }
+-
+- err = native_window_set_buffers_dimensions(window.get(),
++ err = native_window_set_buffers_dimensions(surface.window.get(),
+ create_info->imageExtent.width,
+ create_info->imageExtent.height);
+ if (err != 0) {
+@@ -332,40 +303,37 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ ALOGE("native_window_set_buffers_dimensions(%d,%d) failed: %s (%d)",
+ create_info->imageExtent.width, create_info->imageExtent.height,
+ strerror(-err), err);
+- native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ err = native_window_set_scaling_mode(
+- window.get(), NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
++ surface.window.get(), NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
+ if (err != 0) {
+ // TODO(jessehall): Improve error reporting. Can we enumerate possible
+ // errors and translate them to valid Vulkan result codes?
+ ALOGE("native_window_set_scaling_mode(SCALE_TO_WINDOW) failed: %s (%d)",
+ strerror(-err), err);
+- native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ uint32_t min_undequeued_buffers;
+- err = window->query(window.get(), NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
+- reinterpret_cast<int*>(&min_undequeued_buffers));
++ err = surface.window->query(
++ surface.window.get(), NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
++ reinterpret_cast<int*>(&min_undequeued_buffers));
+ if (err != 0) {
+ // TODO(jessehall): Improve error reporting. Can we enumerate possible
+ // errors and translate them to valid Vulkan result codes?
+ ALOGE("window->query failed: %s (%d)", strerror(-err), err);
+- native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+ uint32_t num_images =
+ (create_info->minImageCount - 1) + min_undequeued_buffers;
+- err = native_window_set_buffer_count(window.get(), num_images);
++ err = native_window_set_buffer_count(surface.window.get(), num_images);
+ if (err != 0) {
+ // TODO(jessehall): Improve error reporting. Can we enumerate possible
+ // errors and translate them to valid Vulkan result codes?
+ ALOGE("native_window_set_buffer_count failed: %s (%d)", strerror(-err),
+ err);
+- native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+@@ -377,31 +345,27 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ &gralloc_usage);
+ if (result != VK_SUCCESS) {
+ ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
+- native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+ } else {
+ gralloc_usage = GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
+ }
+- err = native_window_set_usage(window.get(), gralloc_usage);
++ err = native_window_set_usage(surface.window.get(), gralloc_usage);
+ if (err != 0) {
+ // TODO(jessehall): Improve error reporting. Can we enumerate possible
+ // errors and translate them to valid Vulkan result codes?
+ ALOGE("native_window_set_usage failed: %s (%d)", strerror(-err), err);
+- native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ // -- Allocate our Swapchain object --
+ // After this point, we must deallocate the swapchain on error.
+
+- void* mem = AllocDeviceMem(device, sizeof(Swapchain), alignof(Swapchain),
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+- if (!mem) {
+- native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
++ void* mem = AllocMem(device, sizeof(Swapchain), alignof(Swapchain),
++ VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
++ if (!mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+- }
+- Swapchain* swapchain = new (mem) Swapchain(window, num_images);
++ Swapchain* swapchain = new (mem) Swapchain(surface, num_images);
+
+ // -- Dequeue all buffers and create a VkImage for each --
+ // Any failures during or after this must cancel the dequeued buffers.
+@@ -435,7 +399,8 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ Swapchain::Image& img = swapchain->images[i];
+
+ ANativeWindowBuffer* buffer;
+- err = window->dequeueBuffer(window.get(), &buffer, &img.dequeue_fence);
++ err = surface.window->dequeueBuffer(surface.window.get(), &buffer,
++ &img.dequeue_fence);
+ if (err != 0) {
+ // TODO(jessehall): Improve error reporting. Can we enumerate
+ // possible errors and translate them to valid Vulkan result codes?
+@@ -469,8 +434,8 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ for (uint32_t i = 0; i < num_images; i++) {
+ Swapchain::Image& img = swapchain->images[i];
+ if (img.dequeued) {
+- window->cancelBuffer(window.get(), img.buffer.get(),
+- img.dequeue_fence);
++ surface.window->cancelBuffer(surface.window.get(), img.buffer.get(),
++ img.dequeue_fence);
+ img.dequeue_fence = -1;
+ img.dequeued = false;
+ }
+@@ -481,9 +446,8 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ }
+
+ if (result != VK_SUCCESS) {
+- native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
+ swapchain->~Swapchain();
+- FreeDeviceMem(device, swapchain);
++ FreeMem(device, swapchain);
+ return result;
+ }
+
+@@ -494,7 +458,7 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ VkResult DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain_handle) {
+ const DeviceVtbl& driver_vtbl = GetDriverVtbl(device);
+ Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
+- const std::shared_ptr<ANativeWindow>& window = swapchain->window;
++ const std::shared_ptr<ANativeWindow>& window = swapchain->surface.window;
+
+ for (uint32_t i = 0; i < swapchain->num_images; i++) {
+ Swapchain::Image& img = swapchain->images[i];
+@@ -509,9 +473,8 @@ VkResult DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain_handle) {
+ }
+ }
+
+- native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
+ swapchain->~Swapchain();
+- FreeDeviceMem(device, swapchain);
++ FreeMem(device, swapchain);
+
+ return VK_SUCCESS;
+ }
+@@ -541,6 +504,7 @@ VkResult AcquireNextImageKHR(VkDevice device,
+ VkSemaphore semaphore,
+ uint32_t* image_index) {
+ Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
++ ANativeWindow* window = swapchain.surface.window.get();
+ VkResult result;
+ int err;
+
+@@ -550,8 +514,7 @@ VkResult AcquireNextImageKHR(VkDevice device,
+
+ ANativeWindowBuffer* buffer;
+ int fence;
+- err = swapchain.window->dequeueBuffer(swapchain.window.get(), &buffer,
+- &fence);
++ err = window->dequeueBuffer(window, &buffer, &fence);
+ if (err != 0) {
+ // TODO(jessehall): Improve error reporting. Can we enumerate possible
+ // errors and translate them to valid Vulkan result codes?
+@@ -569,7 +532,7 @@ VkResult AcquireNextImageKHR(VkDevice device,
+ }
+ if (idx == swapchain.num_images) {
+ ALOGE("dequeueBuffer returned unrecognized buffer");
+- swapchain.window->cancelBuffer(swapchain.window.get(), buffer, fence);
++ window->cancelBuffer(window, buffer, fence);
+ #pragma clang diagnostic push
+ #pragma clang diagnostic ignored "-Wold-style-cast"
+ return VK_ERROR_OUT_OF_DATE_KHR;
+@@ -605,7 +568,7 @@ VkResult AcquireNextImageKHR(VkDevice device,
+ // number between the time the driver closes it and the time we close
+ // it. We must assume one of: the driver *always* closes it even on
+ // failure, or *never* closes it on failure.
+- swapchain.window->cancelBuffer(swapchain.window.get(), buffer, fence);
++ window->cancelBuffer(window, buffer, fence);
+ swapchain.images[idx].dequeued = false;
+ swapchain.images[idx].dequeue_fence = -1;
+ return result;
+@@ -630,6 +593,7 @@ VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info) {
+ for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
+ Swapchain& swapchain =
+ *SwapchainFromHandle(present_info->swapchains[sc]);
++ ANativeWindow* window = swapchain.surface.window.get();
+ uint32_t image_idx = present_info->imageIndices[sc];
+ Swapchain::Image& img = swapchain.images[image_idx];
+ VkResult result;
+@@ -656,8 +620,7 @@ VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info) {
+ continue;
+ }
+
+- err = swapchain.window->queueBuffer(swapchain.window.get(),
+- img.buffer.get(), fence);
++ err = window->queueBuffer(window, img.buffer.get(), fence);
+ if (err != 0) {
+ // TODO(jessehall): What now? We should probably cancel the buffer,
+ // I guess?
+--
+2.4.0
+
--- /dev/null
+From 7b91a4939779638ae33ce117e52fc58f911644d2 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Sat, 21 Nov 2015 19:31:56 -0800
+Subject: [PATCH 08/30] vulkan: Update from version 0.183.0 to 0.184.0
+
+Change-Id: I11802010d9171877e3fc8cc6e0931f8c746660c4
+---
+ vulkan/api/vulkan.api | 39 ++++++++++++----------------
+ vulkan/include/vulkan/vulkan.h | 53 +++++++++++++++++++-------------------
+ vulkan/libvulkan/entry.cpp | 21 ++++++---------
+ vulkan/libvulkan/get_proc_addr.cpp | 7 -----
+ vulkan/libvulkan/loader.h | 1 -
+ vulkan/nulldrv/null_driver.cpp | 9 ++-----
+ vulkan/nulldrv/null_driver.h | 5 ++--
+ vulkan/nulldrv/null_driver_gen.cpp | 1 -
+ 8 files changed, 54 insertions(+), 82 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 878cf44..ab1fb1b 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 183
++define VERSION_MINOR 184
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -929,7 +929,7 @@ bitfield VkImageAspectFlags {
+
+ /// Sparse memory bind flags
+ bitfield VkSparseMemoryBindFlags {
+- VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT = 0x00000001, /// Replicate the first 64 KiB memory block to the entire bind rage
++ VK_SPARSE_MEMORY_BIND_REPLICATE_BLOCK_BIT = 0x00000001,
+ }
+
+ /// Sparse image memory requirements flags
+@@ -1433,7 +1433,7 @@ class VkShaderModuleCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+ platform.size_t codeSize /// Specified in bytes
+- const void* pCode /// Binary code of size codeSize
++ const u32* pCode /// Binary code of size codeSize
+ VkShaderModuleCreateFlags flags /// Reserved
+ }
+
+@@ -1566,9 +1566,9 @@ class VkPipelineRasterStateCreateInfo {
+ VkCullMode cullMode
+ VkFrontFace frontFace
+ VkBool32 depthBiasEnable
+- f32 depthBias
++ f32 depthBiasConstantFactor
+ f32 depthBiasClamp
+- f32 slopeScaledDepthBias
++ f32 depthBiasSlopeFactor
+ f32 lineWidth
+ }
+
+@@ -1844,6 +1844,7 @@ class VkPhysicalDeviceFeatures {
+ VkBool32 fillModeNonSolid /// point and wireframe fill modes
+ VkBool32 depthBounds /// depth bounds test
+ VkBool32 wideLines /// lines with width greater than 1
++ VkBool32 strictLines
+ VkBool32 largePoints /// points with size greater than 1
+ VkBool32 alphaToOne /// The fragment alpha channel can be forced to maximum representable alpha value
+ VkBool32 multiViewport
+@@ -1989,7 +1990,7 @@ class VkPhysicalDeviceLimits {
+ u32 maxStorageImageSamples /// max num of samples for a storage image
+ u32 maxSampleMaskWords /// max num of sample mask words
+
+- u64 timestampFrequency /// 1/clock_tick_granularity for timestamp queries
++ f32 timestampPeriod
+
+ u32 maxClipDistances /// max number of clip distances
+ u32 maxCullDistances /// max number of cull distances
+@@ -2001,6 +2002,9 @@ class VkPhysicalDeviceLimits {
+ f32[2] lineWidthRange /// range (min,max) of supported line widths
+ f32 pointSizeGranularity /// granularity of supported point sizes
+ f32 lineWidthGranularity /// granularity of supported line widths
++
++ u32 recommendedBufferCopyOffsetAlignment
++ u32 recommendedBufferCopyRowPitchAlignment
+ }
+
+ class VkPhysicalDeviceSparseProperties {
+@@ -2982,15 +2986,14 @@ cmd VkResult vkGetQueryPoolResults(
+ VkQueryPool queryPool,
+ u32 startQuery,
+ u32 queryCount,
+- platform.size_t* pDataSize,
++ platform.size_t dataSize,
+ void* pData,
++ VkDeviceSize stride,
+ VkQueryResultFlags flags) {
+ deviceObject := GetDevice(device)
+ queryPoolObject := GetQueryPool(queryPool)
+ assert(queryPoolObject.device == device)
+
+- dataSize := ?
+- pDataSize[0] = dataSize
+ data := pData[0:dataSize]
+
+ return ?
+@@ -3209,20 +3212,10 @@ cmd void vkDestroyPipelineCache(
+ State.PipelineCaches[pipelineCache] = null
+ }
+
+-cmd platform.size_t vkGetPipelineCacheSize(
+- VkDevice device,
+- VkPipelineCache pipelineCache) {
+- deviceObject := GetDevice(device)
+- pipelineCacheObject := GetPipelineCache(pipelineCache)
+- assert(pipelineCacheObject.device == device)
+-
+- return ?
+-}
+-
+ cmd VkResult vkGetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+- platform.size_t dataSize,
++ platform.size_t* pDataSize,
+ void* pData) {
+ deviceObject := GetDevice(device)
+ pipelineCacheObject := GetPipelineCache(pipelineCache)
+@@ -3741,9 +3734,9 @@ cmd void vkCmdSetLineWidth(
+ @threadSafety("app")
+ cmd void vkCmdSetDepthBias(
+ VkCmdBuffer cmdBuffer,
+- f32 depthBias,
++ f32 depthBiasConstantFactor,
+ f32 depthBiasClamp,
+- f32 slopeScaledDepthBias) {
++ f32 depthBiasSlopeFactor) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+ cmdBufferObject.queueFlags = queueFlags
+@@ -4357,7 +4350,7 @@ cmd void vkCmdCopyQueryPoolResults(
+ u32 queryCount,
+ VkBuffer destBuffer,
+ VkDeviceSize destOffset,
+- VkDeviceSize destStride,
++ VkDeviceSize stride,
+ VkQueryResultFlags flags) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ queryPoolObject := GetQueryPool(queryPool)
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index ee921bf..75d1358 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 183, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 184, 0)
+
+
+ #if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
+@@ -85,7 +85,7 @@ extern "C" {
+ #else
+ #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T { uint64_t handle; } obj;
+ #endif
+-
++
+
+
+ typedef uint32_t VkBool32;
+@@ -877,7 +877,7 @@ typedef enum {
+ typedef VkFlags VkSparseImageFormatFlags;
+
+ typedef enum {
+- VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT = 0x00000001,
++ VK_SPARSE_MEMORY_BIND_REPLICATE_BLOCK_BIT = 0x00000001,
+ } VkSparseMemoryBindFlagBits;
+ typedef VkFlags VkSparseMemoryBindFlags;
+
+@@ -1112,6 +1112,7 @@ typedef struct {
+ VkBool32 fillModeNonSolid;
+ VkBool32 depthBounds;
+ VkBool32 wideLines;
++ VkBool32 strictLines;
+ VkBool32 largePoints;
+ VkBool32 alphaToOne;
+ VkBool32 multiViewport;
+@@ -1260,7 +1261,7 @@ typedef struct {
+ uint32_t maxSampledImageIntegerSamples;
+ uint32_t maxStorageImageSamples;
+ uint32_t maxSampleMaskWords;
+- uint64_t timestampFrequency;
++ float timestampPeriod;
+ uint32_t maxClipDistances;
+ uint32_t maxCullDistances;
+ uint32_t maxCombinedClipAndCullDistances;
+@@ -1269,6 +1270,8 @@ typedef struct {
+ float lineWidthRange[2];
+ float pointSizeGranularity;
+ float lineWidthGranularity;
++ uint32_t recommendedBufferCopyOffsetAlignment;
++ uint32_t recommendedBufferCopyRowPitchAlignment;
+ } VkPhysicalDeviceLimits;
+
+ typedef struct {
+@@ -1521,7 +1524,7 @@ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ size_t codeSize;
+- const void* pCode;
++ const uint32_t* pCode;
+ VkShaderModuleCreateFlags flags;
+ } VkShaderModuleCreateInfo;
+
+@@ -1640,9 +1643,9 @@ typedef struct {
+ VkCullMode cullMode;
+ VkFrontFace frontFace;
+ VkBool32 depthBiasEnable;
+- float depthBias;
++ float depthBiasConstantFactor;
+ float depthBiasClamp;
+- float slopeScaledDepthBias;
++ float depthBiasSlopeFactor;
+ float lineWidth;
+ } VkPipelineRasterStateCreateInfo;
+
+@@ -2132,7 +2135,7 @@ typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
+ typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
+ typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
+ typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool);
+-typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags);
++typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+ typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
+ typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer);
+ typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
+@@ -2148,8 +2151,7 @@ typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCrea
+ typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader);
+ typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
+ typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
+-typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache);
+-typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData);
++typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+ typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+ typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+ typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+@@ -2183,7 +2185,7 @@ typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBin
+ typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
+ typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
+ typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth);
+-typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias);
++typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
+ typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConst[4]);
+ typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
+ typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
+@@ -2217,7 +2219,7 @@ typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool que
+ typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+ typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+ typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset);
+-typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
++typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+ typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
+ typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+ typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents);
+@@ -2491,8 +2493,9 @@ VkResult VKAPI vkGetQueryPoolResults(
+ VkQueryPool queryPool,
+ uint32_t startQuery,
+ uint32_t queryCount,
+- size_t* pDataSize,
++ size_t dataSize,
+ void* pData,
++ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+
+ VkResult VKAPI vkCreateBuffer(
+@@ -2564,14 +2567,10 @@ void VKAPI vkDestroyPipelineCache(
+ VkDevice device,
+ VkPipelineCache pipelineCache);
+
+-size_t VKAPI vkGetPipelineCacheSize(
+- VkDevice device,
+- VkPipelineCache pipelineCache);
+-
+ VkResult VKAPI vkGetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+- size_t dataSize,
++ size_t* pDataSize,
+ void* pData);
+
+ VkResult VKAPI vkMergePipelineCaches(
+@@ -2737,9 +2736,9 @@ void VKAPI vkCmdSetLineWidth(
+
+ void VKAPI vkCmdSetDepthBias(
+ VkCmdBuffer cmdBuffer,
+- float depthBias,
++ float depthBiasConstantFactor,
+ float depthBiasClamp,
+- float slopeScaledDepthBias);
++ float depthBiasSlopeFactor);
+
+ void VKAPI vkCmdSetBlendConstants(
+ VkCmdBuffer cmdBuffer,
+@@ -2973,7 +2972,7 @@ void VKAPI vkCmdCopyQueryPoolResults(
+ uint32_t queryCount,
+ VkBuffer destBuffer,
+ VkDeviceSize destOffset,
+- VkDeviceSize destStride,
++ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+
+ void VKAPI vkCmdPushConstants(
+@@ -3317,8 +3316,8 @@ typedef struct {
+
+
+
+-#define vk_ext_khr_x11_surface 1
+ #ifdef VK_USE_PLATFORM_X11_KHR
++#define vk_ext_khr_x11_surface 1
+ #include <X11/Xlib.h>
+
+ #define VK_EXT_KHR_X11_SURFACE_REVISION 1
+@@ -3337,8 +3336,8 @@ VkResult VKAPI vkCreateX11SurfaceKHR(
+ #endif
+ #endif /* VK_USE_PLATFORM_X11_KHR */
+
+-#define vk_ext_khr_xcb_surface 1
+ #ifdef VK_USE_PLATFORM_XCB_KHR
++#define vk_ext_khr_xcb_surface 1
+ #include <xcb/xcb.h>
+
+ #define VK_EXT_KHR_XCB_SURFACE_REVISION 1
+@@ -3357,8 +3356,8 @@ VkResult VKAPI vkCreateXcbSurfaceKHR(
+ #endif
+ #endif /* VK_USE_PLATFORM_XCB_KHR */
+
+-#define vk_ext_khr_wayland_surface 1
+ #ifdef VK_USE_PLATFORM_WAYLAND_KHR
++#define vk_ext_khr_wayland_surface 1
+ #include <wayland-client.h>
+
+ #define VK_EXT_KHR_WAYLAND_SURFACE_REVISION 1
+@@ -3376,8 +3375,8 @@ VkResult VKAPI vkCreateWaylandSurfaceKHR(
+ #endif
+ #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
+
+-#define vk_ext_khr_mir_surface 1
+ #ifdef VK_USE_PLATFORM_MIR_KHR
++#define vk_ext_khr_mir_surface 1
+ #include <mir_toolkit/client_types.h>
+
+ #define VK_EXT_KHR_MIR_SURFACE_REVISION 1
+@@ -3395,8 +3394,8 @@ VkResult VKAPI vkCreateMirSurfaceKHR(
+ #endif
+ #endif /* VK_USE_PLATFORM_MIR_KHR */
+
+-#define vk_ext_khr_android_surface 1
+ #ifdef VK_USE_PLATFORM_ANDROID_KHR
++#define vk_ext_khr_android_surface 1
+ #include <android/native_window.h>
+
+ #define VK_EXT_KHR_ANDROID_SURFACE_REVISION 1
+@@ -3415,8 +3414,8 @@ VkResult VKAPI vkCreateAndroidSurfaceKHR(
+ #endif
+ #endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
+-#define vk_ext_khr_win32_surface 1
+ #ifdef VK_USE_PLATFORM_WIN32_KHR
++#define vk_ext_khr_win32_surface 1
+ #include <windows.h>
+
+ #define VK_EXT_KHR_WIN32_SURFACE_REVISION 1
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 339101f..0c7533f 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -307,8 +307,8 @@ void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags) {
+- return GetVtbl(device).GetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags);
++VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
++ return GetVtbl(device).GetQueryPoolResults(device, queryPool, startQuery, queryCount, dataSize, pData, stride, flags);
+ }
+
+ __attribute__((visibility("default")))
+@@ -387,13 +387,8 @@ void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache) {
+ }
+
+ __attribute__((visibility("default")))
+-size_t vkGetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache) {
+- return GetVtbl(device).GetPipelineCacheSize(device, pipelineCache);
+-}
+-
+-__attribute__((visibility("default")))
+-VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData) {
+- return GetVtbl(device).GetPipelineCacheData(device, pipelineCache, dataSize, pData);
++VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
++ return GetVtbl(device).GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+ }
+
+ __attribute__((visibility("default")))
+@@ -562,8 +557,8 @@ void vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth) {
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) {
+- GetVtbl(cmdBuffer).CmdSetDepthBias(cmdBuffer, depthBias, depthBiasClamp, slopeScaledDepthBias);
++void vkCmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
++ GetVtbl(cmdBuffer).CmdSetDepthBias(cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+ }
+
+ __attribute__((visibility("default")))
+@@ -732,8 +727,8 @@ void vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, V
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
+- GetVtbl(cmdBuffer).CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
++void vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
++ GetVtbl(cmdBuffer).CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, stride, flags);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
+index f1ad5f3..1135870 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp
++++ b/vulkan/libvulkan/get_proc_addr.cpp
+@@ -179,7 +179,6 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements)},
+ {"vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout)},
+ {"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData)},
+- {"vkGetPipelineCacheSize", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheSize)},
+ {"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults)},
+ {"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity)},
+ {"vkGetSurfaceFormatsKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfaceFormatsKHR)},
+@@ -341,7 +340,6 @@ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ {"vkGetImageSparseMemoryRequirements", offsetof(DeviceVtbl, GetImageSparseMemoryRequirements)},
+ {"vkGetImageSubresourceLayout", offsetof(DeviceVtbl, GetImageSubresourceLayout)},
+ {"vkGetPipelineCacheData", offsetof(DeviceVtbl, GetPipelineCacheData)},
+- {"vkGetPipelineCacheSize", offsetof(DeviceVtbl, GetPipelineCacheSize)},
+ {"vkGetQueryPoolResults", offsetof(DeviceVtbl, GetQueryPoolResults)},
+ {"vkGetRenderAreaGranularity", offsetof(DeviceVtbl, GetRenderAreaGranularity)},
+ {"vkGetSurfaceFormatsKHR", offsetof(DeviceVtbl, GetSurfaceFormatsKHR)},
+@@ -772,11 +770,6 @@ bool LoadDeviceVtbl(VkDevice device,
+ ALOGE("missing device proc: %s", "vkDestroyPipelineCache");
+ success = false;
+ }
+- vtbl.GetPipelineCacheSize = reinterpret_cast<PFN_vkGetPipelineCacheSize>(get_proc_addr(device, "vkGetPipelineCacheSize"));
+- if (UNLIKELY(!vtbl.GetPipelineCacheSize)) {
+- ALOGE("missing device proc: %s", "vkGetPipelineCacheSize");
+- success = false;
+- }
+ vtbl.GetPipelineCacheData = reinterpret_cast<PFN_vkGetPipelineCacheData>(get_proc_addr(device, "vkGetPipelineCacheData"));
+ if (UNLIKELY(!vtbl.GetPipelineCacheData)) {
+ ALOGE("missing device proc: %s", "vkGetPipelineCacheData");
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index 3e34e75..e8ad915 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -106,7 +106,6 @@ struct DeviceVtbl {
+ PFN_vkDestroyShader DestroyShader;
+ PFN_vkCreatePipelineCache CreatePipelineCache;
+ PFN_vkDestroyPipelineCache DestroyPipelineCache;
+- PFN_vkGetPipelineCacheSize GetPipelineCacheSize;
+ PFN_vkGetPipelineCacheData GetPipelineCacheData;
+ PFN_vkMergePipelineCaches MergePipelineCaches;
+ PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines;
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 7e890be..d3580a5 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -835,7 +835,7 @@ VkResult ResetEvent(VkDevice device, VkEvent event) {
+ void DestroyQueryPool(VkDevice device, VkQueryPool queryPool) {
+ }
+
+-VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags) {
++VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ return VK_SUCCESS;
+ }
+@@ -859,12 +859,7 @@ void DestroyShader(VkDevice device, VkShader shader) {
+ void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache) {
+ }
+
+-size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache) {
+- ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+-}
+-
+-VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData) {
++VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ return VK_SUCCESS;
+ }
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index c35df18..5fd3acf 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -79,7 +79,7 @@ VkResult SetEvent(VkDevice device, VkEvent event);
+ VkResult ResetEvent(VkDevice device, VkEvent event);
+ VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
+ void DestroyQueryPool(VkDevice device, VkQueryPool queryPool);
+-VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags);
++VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+ VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
+ void DestroyBuffer(VkDevice device, VkBuffer buffer);
+ VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
+@@ -95,8 +95,7 @@ VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, Vk
+ void DestroyShader(VkDevice device, VkShader shader);
+ VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
+ void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache);
+-size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache);
+-VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData);
++VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+ VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+ VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+ VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
+index 431977d..31c56ff 100644
+--- a/vulkan/nulldrv/null_driver_gen.cpp
++++ b/vulkan/nulldrv/null_driver_gen.cpp
+@@ -173,7 +173,6 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetImageSparseMemoryRequirements>(GetImageSparseMemoryRequirements))},
+ {"vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetImageSubresourceLayout>(GetImageSubresourceLayout))},
+ {"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPipelineCacheData>(GetPipelineCacheData))},
+- {"vkGetPipelineCacheSize", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPipelineCacheSize>(GetPipelineCacheSize))},
+ {"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetQueryPoolResults>(GetQueryPoolResults))},
+ {"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetRenderAreaGranularity>(GetRenderAreaGranularity))},
+ {"vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkInvalidateMappedMemoryRanges>(InvalidateMappedMemoryRanges))},
+--
+2.4.0
+
--- /dev/null
+From d8e4b9a6523599305b93655a1b6cfbcc28530cf6 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Tue, 24 Nov 2015 10:24:18 -0800
+Subject: [PATCH 09/30] vulkan.api: Distinguish Vk*Flags from Vk*FlagBits
+
+Previously Vulkan never used the *FlagBits enums directly as the type
+of a parameter or field, only ever using the *Flags typedef. For cases
+when a variable should have exactl one of the options, a separate enum
+was used. Now Vulkan is switching to using the *FlagBits enum for such
+variables, to avoid needing two separate enums for the same thing.
+
+The API file didn't distinguish between these before, it only had one
+type for the bitfield, and the vulkan_h.tmpl template synthesized the
+*FlagBits name from the *Flags name during generation. Now that we
+have cases where some variables need the *FlagBits type and some need
+the *Flags type, we need to distinguish them in the API file. This
+change does that.
+
+This required some ugly casting in a few places to get around apic's
+strict operand type compatibility rules. Most of these can go away
+once b/25863296 is fixed.
+
+Change-Id: Ia153d4b0c91abe80e4c34a284ca9d721cc770795
+---
+ vulkan/api/vulkan.api | 229 +++++++++++++++++++++++++++-----------------------
+ 1 file changed, 122 insertions(+), 107 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index ab1fb1b..6f8c0d8 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -713,7 +713,8 @@ enum VkColorSpaceKHR {
+ /////////////////
+
+ /// Queue capabilities
+-bitfield VkQueueFlags {
++type VkFlags VkQueueFlags
++bitfield VkQueueFlagBits {
+ VK_QUEUE_GRAPHICS_BIT = 0x00000001, /// Queue supports graphics operations
+ VK_QUEUE_COMPUTE_BIT = 0x00000002, /// Queue supports compute operations
+ VK_QUEUE_DMA_BIT = 0x00000004, /// Queue supports DMA operations
+@@ -722,7 +723,8 @@ bitfield VkQueueFlags {
+ }
+
+ /// Memory properties passed into vkAllocMemory().
+-bitfield VkMemoryPropertyFlags {
++type VkFlags VkMemoryPropertyFlags
++bitfield VkMemoryPropertyFlagBits {
+ VK_MEMORY_PROPERTY_DEVICE_ONLY = 0x00000000, /// If otherwise stated, then allocate memory on device
+ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001, /// Memory should be mappable by host
+ VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, /// Memory may not have i/o coherency so vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges must be used flush/invalidate host cache
+@@ -732,12 +734,14 @@ bitfield VkMemoryPropertyFlags {
+ }
+
+ /// Memory heap flags
+-bitfield VkMemoryHeapFlags {
++type VkFlags VkMemoryHeapFlags
++bitfield VkMemoryHeapFlagBits {
+ VK_MEMORY_HEAP_HOST_LOCAL_BIT = 0x00000001, /// If set, heap represents host memory
+ }
+
+ /// Memory output flags passed to resource transition commands
+-bitfield VkMemoryOutputFlags {
++type VkFlags VkMemoryOutputFlags
++bitfield VkMemoryOutputFlagBits {
+ VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, /// Controls output coherency of host writes
+ VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, /// Controls output coherency of generic shader writes
+ VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, /// Controls output coherency of color attachment writes
+@@ -746,7 +750,8 @@ bitfield VkMemoryOutputFlags {
+ }
+
+ /// Memory input flags passed to resource transition commands
+-bitfield VkMemoryInputFlags {
++type VkFlags VkMemoryInputFlags
++bitfield VkMemoryInputFlagBits {
+ VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, /// Controls input coherency of host reads
+ VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, /// Controls input coherency of indirect command reads
+ VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, /// Controls input coherency of index fetches
+@@ -760,7 +765,8 @@ bitfield VkMemoryInputFlags {
+ }
+
+ /// Buffer usage flags
+-bitfield VkBufferUsageFlags {
++type VkFlags VkBufferUsageFlags
++bitfield VkBufferUsageFlagBits {
+ VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, /// Can be used as a source of transfer operations
+ VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, /// Can be used as a destination of transfer operations
+ VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, /// Can be used as TBO
+@@ -773,14 +779,16 @@ bitfield VkBufferUsageFlags {
+ }
+
+ /// Buffer creation flags
+-bitfield VkBufferCreateFlags {
++type VkFlags VkBufferCreateFlags
++bitfield VkBufferCreateFlagBits {
+ VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, /// Buffer should support sparse backing
+ VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, /// Buffer should support sparse backing with partial residency
+ VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, /// Buffer should support constent data access to physical memory blocks mapped into multiple locations of sparse buffers
+ }
+
+ /// Shader stage flags
+-bitfield VkShaderStageFlags {
++type VkFlags VkShaderStageFlags
++bitfield VkShaderStageFlagBits {
+ VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
+ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
+ VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
+@@ -792,16 +800,19 @@ bitfield VkShaderStageFlags {
+ }
+
+ /// Descriptor pool create flags
+-bitfield VkDescriptorPoolCreateFlags {
++type VkFlags VkDescriptorPoolCreateFlags
++bitfield VkDescriptorPoolCreateFlagBits {
+ VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
+ }
+
+ /// Descriptor pool reset flags
+-bitfield VkDescriptorPoolResetFlags {
++type VkFlags VkDescriptorPoolResetFlags
++bitfield VkDescriptorPoolResetFlagBits {
+ }
+
+ /// Image usage flags
+-bitfield VkImageUsageFlags {
++type VkFlags VkImageUsageFlags
++bitfield VkImageUsageFlagBits {
+ VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, /// Can be used as a source of transfer operations
+ VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, /// Can be used as a destination of transfer operations
+ VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, /// Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
+@@ -813,7 +824,8 @@ bitfield VkImageUsageFlags {
+ }
+
+ /// Image creation flags
+-bitfield VkImageCreateFlags {
++type VkFlags VkImageCreateFlags
++bitfield VkImageCreateFlagBits {
+ VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, /// Image should support sparse backing
+ VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, /// Image should support sparse backing with partial residency
+ VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, /// Image should support constent data access to physical memory blocks mapped into multiple locations of sparse images
+@@ -822,20 +834,23 @@ bitfield VkImageCreateFlags {
+ }
+
+ /// Framebuffer attachment view creation flags
+-bitfield VkImageViewCreateFlags {
++type VkFlags VkImageViewCreateFlags
++bitfield VkImageViewCreateFlagBits {
+ VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
+ VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
+ }
+
+ /// Pipeline creation flags
+-bitfield VkPipelineCreateFlags {
++type VkFlags VkPipelineCreateFlags
++bitfield VkPipelineCreateFlagBits {
+ VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
+ VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
+ VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
+ }
+
+ /// Channel flags
+-bitfield VkChannelFlags {
++type VkFlags VkChannelFlags
++bitfield VkChannelFlagBits {
+ VK_CHANNEL_R_BIT = 0x00000001,
+ VK_CHANNEL_G_BIT = 0x00000002,
+ VK_CHANNEL_B_BIT = 0x00000004,
+@@ -843,16 +858,19 @@ bitfield VkChannelFlags {
+ }
+
+ /// Fence creation flags
+-bitfield VkFenceCreateFlags {
++type VkFlags VkFenceCreateFlags
++bitfield VkFenceCreateFlagBits {
+ VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
+ }
+
+ /// Semaphore creation flags
+-bitfield VkSemaphoreCreateFlags {
++type VkFlags VkSemaphoreCreateFlags
++bitfield VkSemaphoreCreateFlagBits {
+ }
+
+ /// Format capability flags
+-bitfield VkFormatFeatureFlags {
++type VkFlags VkFormatFeatureFlags
++bitfield VkFormatFeatureFlagBits {
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, /// Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
+ VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, /// Format can be used for storage images (STORAGE_IMAGE descriptor type)
+ VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, /// Format supports atomic operations in case it's used for storage images
+@@ -868,12 +886,14 @@ bitfield VkFormatFeatureFlags {
+ }
+
+ /// Query control flags
+-bitfield VkQueryControlFlags {
++type VkFlags VkQueryControlFlags
++bitfield VkQueryControlFlagBits {
+ VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, /// Allow conservative results to be collected by the query
+ }
+
+ /// Query result flags
+-bitfield VkQueryResultFlags {
++type VkFlags VkQueryResultFlags
++bitfield VkQueryResultFlagBits {
+ VK_QUERY_RESULT_DEFAULT = 0x00000000, /// Results of the queries are immediately written to the destination buffer as 32-bit values
+ VK_QUERY_RESULT_64_BIT = 0x00000001, /// Results of the queries are written to the destination buffer as 64-bit values
+ VK_QUERY_RESULT_WAIT_BIT = 0x00000002, /// Results of the queries are waited on before proceeding with the result copy
+@@ -882,26 +902,31 @@ bitfield VkQueryResultFlags {
+ }
+
+ /// Shader module creation flags
+-bitfield VkShaderModuleCreateFlags {
++type VkFlags VkShaderModuleCreateFlags
++bitfield VkShaderModuleCreateFlagBits {
+ }
+
+ /// Shader creation flags
+-bitfield VkShaderCreateFlags {
++type VkFlags VkShaderCreateFlags
++bitfield VkShaderCreateFlagBits {
+ }
+
+ /// Event creation flags
+-bitfield VkEventCreateFlags {
++type VkFlags VkEventCreateFlags
++bitfield VkEventCreateFlagBits {
+ }
+
+ /// Command buffer usage flags
+-bitfield VkCmdBufferUsageFlags {
++type VkFlags VkCmdBufferUsageFlags
++bitfield VkCmdBufferUsageFlagBits {
+ VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
+ VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
+ VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
+ }
+
+ /// Pipeline statistics flags
+-bitfield VkQueryPipelineStatisticFlags {
++type VkFlags VkQueryPipelineStatisticFlags
++bitfield VkQueryPipelineStatisticFlagBits {
+ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, /// Optional
+ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, /// Optional
+ VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, /// Optional
+@@ -916,11 +941,13 @@ bitfield VkQueryPipelineStatisticFlags {
+ }
+
+ /// Memory mapping flags
+-bitfield VkMemoryMapFlags {
++type VkFlags VkMemoryMapFlags
++bitfield VkMemoryMapFlagBits {
+ }
+
+ /// Bitfield of image aspects
+-bitfield VkImageAspectFlags {
++type VkFlags VkImageAspectFlags
++bitfield VkImageAspectFlagBits {
+ VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
+ VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
+ VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
+@@ -928,19 +955,22 @@ bitfield VkImageAspectFlags {
+ }
+
+ /// Sparse memory bind flags
+-bitfield VkSparseMemoryBindFlags {
++type VkFlags VkSparseMemoryBindFlags
++bitfield VkSparseMemoryBindFlagBits {
+ VK_SPARSE_MEMORY_BIND_REPLICATE_BLOCK_BIT = 0x00000001,
+ }
+
+ /// Sparse image memory requirements flags
+-bitfield VkSparseImageFormatFlags {
++type VkFlags VkSparseImageFormatFlags
++bitfield VkSparseImageFormatFlagBits {
+ VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001, /// Image uses a single miptail region for all array slices
+ VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002, /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels.
+ VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004, /// Image uses a non-standard sparse block size
+ }
+
+ /// Pipeline stages
+-bitfield VkPipelineStageFlags {
++type VkFlags VkPipelineStageFlags
++bitfield VkPipelineStageFlagBits {
+ VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, /// Before subsequent commands are processed
+ VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, /// Draw/DispatchIndirect command fetch
+ VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, /// Vertex/index fetch
+@@ -961,30 +991,36 @@ bitfield VkPipelineStageFlags {
+ }
+
+ /// Render pass attachment description flags
+-bitfield VkAttachmentDescriptionFlags {
++type VkFlags VkAttachmentDescriptionFlags
++bitfield VkAttachmentDescriptionFlagBits {
+ VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, /// The attachment may alias physical memory of another attachment in the same renderpass
+ }
+
+ /// Subpass description flags
+-bitfield VkSubpassDescriptionFlags {
++type VkFlags VkSubpassDescriptionFlags
++bitfield VkSubpassDescriptionFlagBits {
+ }
+
+ /// Command pool creation flags
+-bitfield VkCmdPoolCreateFlags {
++type VkFlags VkCmdPoolCreateFlags
++bitfield VkCmdPoolCreateFlagBits {
+ VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001, /// Command buffers have a short lifetime
+ VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, /// Command buffers may release their memory individually
+ }
+
+ /// Command pool reset flags
+-bitfield VkCmdPoolResetFlags {
++type VkFlags VkCmdPoolResetFlags
++bitfield VkCmdPoolResetFlagBits {
+ VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the pool
+ }
+
+-bitfield VkCmdBufferResetFlags {
++type VkFlags VkCmdBufferResetFlags
++bitfield VkCmdBufferResetFlagBits {
+ VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the buffer
+ }
+
+-bitfield VkSampleCountFlags {
++type VkFlags VkSampleCountFlags
++bitfield VkSampleCountFlagBits {
+ VK_SAMPLE_COUNT_1_BIT = 0x00000001,
+ VK_SAMPLE_COUNT_2_BIT = 0x00000002,
+ VK_SAMPLE_COUNT_4_BIT = 0x00000004,
+@@ -994,14 +1030,17 @@ bitfield VkSampleCountFlags {
+ VK_SAMPLE_COUNT_64_BIT = 0x00000040,
+ }
+
+-bitfield VkStencilFaceFlags {
++type VkFlags VkStencilFaceFlags
++bitfield VkStencilFaceFlagBits {
+ VK_STENCIL_FACE_NONE = 0x00000000, /// No faces
+ VK_STENCIL_FACE_FRONT_BIT = 0x00000001, /// Front face
+ VK_STENCIL_FACE_BACK_BIT = 0x00000002, /// Back face
+ }
+
+ @extension("VK_EXT_KHR_swapchain")
+-bitfield VkSurfaceTransformFlagsKHR {
++type VkFlags VkSurfaceTransformFlagsKHR
++@extension("VK_EXT_KHR_swapchain")
++bitfield VkSurfaceTransformFlagBitsKHR {
+ VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
+ VK_SURFACE_TRANSFORM_ROT90_BIT_KHR = 0x00000002,
+ VK_SURFACE_TRANSFORM_ROT180_BIT_KHR = 0x00000004,
+@@ -1014,7 +1053,9 @@ bitfield VkSurfaceTransformFlagsKHR {
+ }
+
+ @extension("VK_EXT_KHR_display")
+-bitfield VkDisplayPlaneAlphaFlagsKHR {
++type VkFlags VkDisplayPlaneAlphaFlagsKHR
++@extension("VK_EXT_KHR_display")
++bitfield VkDisplayPlaneAlphaFlagBitsKHR {
+ VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000001,
+ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000002,
+ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000004,
+@@ -1181,7 +1222,7 @@ class VkMemoryRequirements {
+ }
+
+ class VkSparseImageFormatProperties {
+- VkImageAspectFlags aspect
++ VkImageAspectFlagBits aspect
+ VkExtent3D imageGranularity
+ VkSparseImageFormatFlags flags
+ }
+@@ -1284,7 +1325,7 @@ class VkBufferViewCreateInfo {
+ }
+
+ class VkImageSubresource {
+- VkImageAspectFlags aspect
++ VkImageAspectFlagBits aspect
+ u32 mipLevel
+ u32 arrayLayer
+ }
+@@ -1443,7 +1484,7 @@ class VkShaderCreateInfo {
+ VkShaderModule module /// Module containing entry point
+ const char* pName /// Null-terminated entry point name
+ VkShaderCreateFlags flags /// Reserved
+- VkShaderStageFlags stage
++ VkShaderStageFlagBits stage
+ }
+
+ class VkDescriptorSetLayoutBinding {
+@@ -2774,7 +2815,7 @@ cmd VkResult vkCreateFence(
+ fence := ?
+ pFence[0] = fence
+ State.Fences[fence] = new!FenceObject(
+- device: device, signaled: (pCreateInfo.flags == VK_FENCE_CREATE_SIGNALED_BIT))
++ device: device, signaled: (pCreateInfo.flags == as!VkFenceCreateFlags(VK_FENCE_CREATE_SIGNALED_BIT)))
+
+ return ?
+ }
+@@ -3695,11 +3736,11 @@ cmd void vkCmdBindPipeline(
+ pipelineObject := GetPipeline(pipeline)
+ assert(cmdBufferObject.device == pipelineObject.device)
+
+- queueFlags := cmdBufferObject.queueFlags | switch (pipelineBindPoint) {
++ queue := switch (pipelineBindPoint) {
+ case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT
+ case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
+ }
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, queue)
+ }
+
+ @threadSafety("app")
+@@ -3708,8 +3749,7 @@ cmd void vkCmdSetViewport(
+ u32 viewportCount,
+ const VkViewport* pViewports) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3718,8 +3758,7 @@ cmd void vkCmdSetScissor(
+ u32 scissorCount,
+ const VkRect2D* pScissors) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3727,8 +3766,7 @@ cmd void vkCmdSetLineWidth(
+ VkCmdBuffer cmdBuffer,
+ f32 lineWidth) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3738,8 +3776,7 @@ cmd void vkCmdSetDepthBias(
+ f32 depthBiasClamp,
+ f32 depthBiasSlopeFactor) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3750,8 +3787,7 @@ cmd void vkCmdSetBlendConstants(
+ // having to modify the AST and semantic model.
+ @readonly f32[4] blendConst) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3760,8 +3796,7 @@ cmd void vkCmdSetDepthBounds(
+ f32 minDepthBounds,
+ f32 maxDepthBounds) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3770,8 +3805,7 @@ cmd void vkCmdSetStencilCompareMask(
+ VkStencilFaceFlags faceMask,
+ u32 stencilCompareMask) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3780,8 +3814,7 @@ cmd void vkCmdSetStencilWriteMask(
+ VkStencilFaceFlags faceMask,
+ u32 stencilWriteMask) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3790,8 +3823,7 @@ cmd void vkCmdSetStencilReference(
+ VkStencilFaceFlags faceMask,
+ u32 stencilReference) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3818,11 +3850,11 @@ cmd void vkCmdBindDescriptorSets(
+ dynamicOffset := dynamicOffsets[i]
+ }
+
+- queueFlags := cmdBufferObject.queueFlags | switch (pipelineBindPoint) {
++ queue := switch (pipelineBindPoint) {
+ case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT
+ case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
+ }
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, queue)
+ }
+
+ @threadSafety("app")
+@@ -3837,8 +3869,7 @@ cmd void vkCmdBindIndexBuffer(
+
+ bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3862,8 +3893,7 @@ cmd void vkCmdBindVertexBuffers(
+ bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
+ }
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3875,8 +3905,7 @@ cmd void vkCmdDraw(
+ u32 firstInstance) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3889,8 +3918,7 @@ cmd void vkCmdDrawIndexed(
+ u32 firstInstance) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3906,8 +3934,7 @@ cmd void vkCmdDrawIndirect(
+
+ bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3923,8 +3950,7 @@ cmd void vkCmdDrawIndexedIndirect(
+
+ bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3935,8 +3961,7 @@ cmd void vkCmdDispatch(
+ u32 z) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_COMPUTE_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3950,8 +3975,7 @@ cmd void vkCmdDispatchIndirect(
+
+ bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_COMPUTE_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
+ }
+
+ @threadSafety("app")
+@@ -3975,8 +3999,7 @@ cmd void vkCmdCopyBuffer(
+ bindCmdBuffer(cmdBuffer, srcBuffer, srcBufferObject.mem)
+ bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4002,8 +4025,7 @@ cmd void vkCmdCopyImage(
+ bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
+ bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4030,8 +4052,7 @@ cmd void vkCmdBlitImage(
+ bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
+ bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4056,8 +4077,7 @@ cmd void vkCmdCopyBufferToImage(
+ bindCmdBuffer(cmdBuffer, srcBuffer, srcBufferObject.mem)
+ bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4082,8 +4102,7 @@ cmd void vkCmdCopyImageToBuffer(
+ bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
+ bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4101,8 +4120,7 @@ cmd void vkCmdUpdateBuffer(
+
+ bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4116,8 +4134,7 @@ cmd void vkCmdFillBuffer(
+ destBufferObject := GetBuffer(destBuffer)
+ assert(cmdBufferObject.device == destBufferObject.device)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4139,8 +4156,7 @@ cmd void vkCmdClearColorImage(
+
+ bindCmdBuffer(cmdBuffer, image, imageObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4162,8 +4178,7 @@ cmd void vkCmdClearDepthStencilImage(
+
+ bindCmdBuffer(cmdBuffer, image, imageObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4180,8 +4195,7 @@ cmd void vkCmdClearAttachments(
+ rect := rects[i]
+ }
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4207,8 +4221,7 @@ cmd void vkCmdResolveImage(
+ bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
+ bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4382,8 +4395,7 @@ cmd void vkCmdBeginRenderPass(
+ assert(cmdBufferObject.device == renderPassObject.device)
+ assert(cmdBufferObject.device == framebufferObject.device)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ cmd void vkCmdNextSubpass(
+@@ -4397,8 +4409,7 @@ cmd void vkCmdEndRenderPass(
+ VkCmdBuffer cmdBuffer) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+
+- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
+- cmdBufferObject.queueFlags = queueFlags
++ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ cmd void vkCmdExecuteCommands(
+@@ -4979,3 +4990,7 @@ macro ref!SwapchainObject GetSwapchain(VkSwapchainKHR swapchain) {
+ assert(swapchain in State.Swapchains)
+ return State.Swapchains[swapchain]
+ }
++
++macro VkQueueFlags AddQueueFlag(VkQueueFlags flags, VkQueueFlagBits bit) {
++ return as!VkQueueFlags(as!u32(flags) | as!u32(bit))
++}
+--
+2.4.0
+
--- /dev/null
+From e17cd31aef5ad14e28324af3262c79333cceb5bf Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Tue, 24 Nov 2015 11:08:36 -0800
+Subject: [PATCH 10/30] vulkan: Update from version 0.184.0 to 0.185.0
+
+Change-Id: I1d6012db32441fe3a99480bfed0e41dfce068980
+---
+ vulkan/api/vulkan.api | 32 ++------------------------------
+ vulkan/include/vulkan/vulkan.h | 26 +++-----------------------
+ vulkan/libvulkan/entry.cpp | 14 ++------------
+ vulkan/libvulkan/get_proc_addr.cpp | 14 --------------
+ vulkan/libvulkan/loader.h | 2 --
+ vulkan/nulldrv/null_driver.cpp | 11 +----------
+ vulkan/nulldrv/null_driver.h | 4 +---
+ vulkan/nulldrv/null_driver_gen.cpp | 2 --
+ 8 files changed, 9 insertions(+), 96 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 6f8c0d8..525b307 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 184
++define VERSION_MINOR 185
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -217,11 +217,6 @@ enum VkQueryType {
+ VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001, /// Optional
+ }
+
+-enum VkTimestampType {
+- VK_TIMESTAMP_TYPE_TOP = 0x00000000,
+- VK_TIMESTAMP_TYPE_BOTTOM = 0x00000001,
+-}
+-
+ enum VkBorderColor {
+ VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0x00000000,
+ VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 0x00000001,
+@@ -1539,7 +1534,6 @@ class VkSpecializationInfo {
+ class VkPipelineShaderStageCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- VkShaderStageFlags stage
+ VkShader shader
+ const VkSpecializationInfo* pSpecializationInfo
+ }
+@@ -2908,28 +2902,6 @@ cmd void vkDestroySemaphore(
+ State.Semaphores[semaphore] = null
+ }
+
+-@threadSafety("app")
+-cmd VkResult vkQueueSignalSemaphore(
+- VkQueue queue,
+- VkSemaphore semaphore) {
+- queueObject := GetQueue(queue)
+- semaphoreObject := GetSemaphore(semaphore)
+- assert(queueObject.device == semaphoreObject.device)
+-
+- return ?
+-}
+-
+-@threadSafety("system")
+-cmd VkResult vkQueueWaitSemaphore(
+- VkQueue queue,
+- VkSemaphore semaphore) {
+- queueObject := GetQueue(queue)
+- semaphoreObject := GetSemaphore(semaphore)
+- assert(queueObject.device == semaphoreObject.device)
+-
+- return ?
+-}
+-
+
+ // Event functions
+
+@@ -4347,7 +4319,7 @@ cmd void vkCmdResetQueryPool(
+ @threadSafety("app")
+ cmd void vkCmdWriteTimestamp(
+ VkCmdBuffer cmdBuffer,
+- VkTimestampType timestampType,
++ VkPipelineStageFlagBits pipelineStage,
+ VkBuffer destBuffer,
+ VkDeviceSize destOffset) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 75d1358..c0f3bc7 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 184, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 185, 0)
+
+
+ #if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
+@@ -772,15 +772,6 @@ typedef enum {
+ } VkIndexType;
+
+ typedef enum {
+- VK_TIMESTAMP_TYPE_TOP = 0,
+- VK_TIMESTAMP_TYPE_BOTTOM = 1,
+- VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TYPE_TOP,
+- VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_TYPE_BOTTOM,
+- VK_TIMESTAMP_TYPE_NUM = (VK_TIMESTAMP_TYPE_BOTTOM - VK_TIMESTAMP_TYPE_TOP + 1),
+- VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF
+-} VkTimestampType;
+-
+-typedef enum {
+ VK_RENDER_PASS_CONTENTS_INLINE = 0,
+ VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1,
+ VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE,
+@@ -1561,7 +1552,6 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkShaderStageFlagBits stage;
+ VkShader shader;
+ const VkSpecializationInfo* pSpecializationInfo;
+ } VkPipelineShaderStageCreateInfo;
+@@ -2126,8 +2116,6 @@ typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
+ typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
+ typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
+ typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore);
+-typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore);
+-typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore);
+ typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
+ typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event);
+ typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
+@@ -2218,7 +2206,7 @@ typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipeline
+ typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+ typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+ typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+-typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset);
++typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset);
+ typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+ typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
+ typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+@@ -2450,14 +2438,6 @@ void VKAPI vkDestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore);
+
+-VkResult VKAPI vkQueueSignalSemaphore(
+- VkQueue queue,
+- VkSemaphore semaphore);
+-
+-VkResult VKAPI vkQueueWaitSemaphore(
+- VkQueue queue,
+- VkSemaphore semaphore);
+-
+ VkResult VKAPI vkCreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+@@ -2961,7 +2941,7 @@ void VKAPI vkCmdResetQueryPool(
+
+ void VKAPI vkCmdWriteTimestamp(
+ VkCmdBuffer cmdBuffer,
+- VkTimestampType timestampType,
++ VkPipelineStageFlagBits pipelineStage,
+ VkBuffer destBuffer,
+ VkDeviceSize destOffset);
+
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 0c7533f..c69b99f 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -262,16 +262,6 @@ void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) {
+- return GetVtbl(queue).QueueSignalSemaphore(queue, semaphore);
+-}
+-
+-__attribute__((visibility("default")))
+-VkResult vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) {
+- return GetVtbl(queue).QueueWaitSemaphore(queue, semaphore);
+-}
+-
+-__attribute__((visibility("default")))
+ VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) {
+ return GetVtbl(device).CreateEvent(device, pCreateInfo, pEvent);
+ }
+@@ -722,8 +712,8 @@ void vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) {
+- GetVtbl(cmdBuffer).CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
++void vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset) {
++ GetVtbl(cmdBuffer).CmdWriteTimestamp(cmdBuffer, pipelineStage, destBuffer, destOffset);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
+index 1135870..68a77d5 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp
++++ b/vulkan/libvulkan/get_proc_addr.cpp
+@@ -192,10 +192,8 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkQueueBindSparseImageMemory", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparseImageMemory)},
+ {"vkQueueBindSparseImageOpaqueMemory", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparseImageOpaqueMemory)},
+ {"vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR)},
+- {"vkQueueSignalSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSignalSemaphore)},
+ {"vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit)},
+ {"vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle)},
+- {"vkQueueWaitSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitSemaphore)},
+ {"vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandBuffer)},
+ {"vkResetCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandPool)},
+ {"vkResetDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetDescriptorPool)},
+@@ -353,10 +351,8 @@ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ {"vkQueueBindSparseImageMemory", offsetof(DeviceVtbl, QueueBindSparseImageMemory)},
+ {"vkQueueBindSparseImageOpaqueMemory", offsetof(DeviceVtbl, QueueBindSparseImageOpaqueMemory)},
+ {"vkQueuePresentKHR", offsetof(DeviceVtbl, QueuePresentKHR)},
+- {"vkQueueSignalSemaphore", offsetof(DeviceVtbl, QueueSignalSemaphore)},
+ {"vkQueueSubmit", offsetof(DeviceVtbl, QueueSubmit)},
+ {"vkQueueWaitIdle", offsetof(DeviceVtbl, QueueWaitIdle)},
+- {"vkQueueWaitSemaphore", offsetof(DeviceVtbl, QueueWaitSemaphore)},
+ {"vkResetCommandBuffer", offsetof(DeviceVtbl, ResetCommandBuffer)},
+ {"vkResetCommandPool", offsetof(DeviceVtbl, ResetCommandPool)},
+ {"vkResetDescriptorPool", offsetof(DeviceVtbl, ResetDescriptorPool)},
+@@ -645,16 +641,6 @@ bool LoadDeviceVtbl(VkDevice device,
+ ALOGE("missing device proc: %s", "vkDestroySemaphore");
+ success = false;
+ }
+- vtbl.QueueSignalSemaphore = reinterpret_cast<PFN_vkQueueSignalSemaphore>(get_proc_addr(device, "vkQueueSignalSemaphore"));
+- if (UNLIKELY(!vtbl.QueueSignalSemaphore)) {
+- ALOGE("missing device proc: %s", "vkQueueSignalSemaphore");
+- success = false;
+- }
+- vtbl.QueueWaitSemaphore = reinterpret_cast<PFN_vkQueueWaitSemaphore>(get_proc_addr(device, "vkQueueWaitSemaphore"));
+- if (UNLIKELY(!vtbl.QueueWaitSemaphore)) {
+- ALOGE("missing device proc: %s", "vkQueueWaitSemaphore");
+- success = false;
+- }
+ vtbl.CreateEvent = reinterpret_cast<PFN_vkCreateEvent>(get_proc_addr(device, "vkCreateEvent"));
+ if (UNLIKELY(!vtbl.CreateEvent)) {
+ ALOGE("missing device proc: %s", "vkCreateEvent");
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index e8ad915..15e2779 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -139,8 +139,6 @@ struct DeviceVtbl {
+ PFN_vkQueueBindSparseBufferMemory QueueBindSparseBufferMemory;
+ PFN_vkQueueBindSparseImageOpaqueMemory QueueBindSparseImageOpaqueMemory;
+ PFN_vkQueueBindSparseImageMemory QueueBindSparseImageMemory;
+- PFN_vkQueueSignalSemaphore QueueSignalSemaphore;
+- PFN_vkQueueWaitSemaphore QueueWaitSemaphore;
+
+ PFN_vkBeginCommandBuffer BeginCommandBuffer;
+ PFN_vkEndCommandBuffer EndCommandBuffer;
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index d3580a5..35f2d84 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -805,15 +805,6 @@ VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFen
+ void DestroySemaphore(VkDevice device, VkSemaphore semaphore) {
+ }
+
+-VkResult QueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) {
+- ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+-}
+-
+-VkResult QueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) {
+- return VK_SUCCESS;
+-}
+-
+ void DestroyEvent(VkDevice device, VkEvent event) {
+ }
+
+@@ -1040,7 +1031,7 @@ void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
+ void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
+ }
+
+-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) {
++void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset) {
+ }
+
+ void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 5fd3acf..f212371 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -70,8 +70,6 @@ VkResult GetFenceStatus(VkDevice device, VkFence fence);
+ VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
+ VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
+ void DestroySemaphore(VkDevice device, VkSemaphore semaphore);
+-VkResult QueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore);
+-VkResult QueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore);
+ VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
+ void DestroyEvent(VkDevice device, VkEvent event);
+ VkResult GetEventStatus(VkDevice device, VkEvent event);
+@@ -162,7 +160,7 @@ void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask
+ void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+ void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+ void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset);
++void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset);
+ void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
+ void CmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
+ void CmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
+index 31c56ff..a026bbf 100644
+--- a/vulkan/nulldrv/null_driver_gen.cpp
++++ b/vulkan/nulldrv/null_driver_gen.cpp
+@@ -181,10 +181,8 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkQueueBindSparseBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueBindSparseBufferMemory>(QueueBindSparseBufferMemory))},
+ {"vkQueueBindSparseImageMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueBindSparseImageMemory>(QueueBindSparseImageMemory))},
+ {"vkQueueBindSparseImageOpaqueMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueBindSparseImageOpaqueMemory>(QueueBindSparseImageOpaqueMemory))},
+- {"vkQueueSignalSemaphore", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueSignalSemaphore>(QueueSignalSemaphore))},
+ {"vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueSubmit>(QueueSubmit))},
+ {"vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueWaitIdle>(QueueWaitIdle))},
+- {"vkQueueWaitSemaphore", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueWaitSemaphore>(QueueWaitSemaphore))},
+ {"vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkResetCommandBuffer>(ResetCommandBuffer))},
+ {"vkResetCommandPool", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkResetCommandPool>(ResetCommandPool))},
+ {"vkResetDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkResetDescriptorPool>(ResetDescriptorPool))},
+--
+2.4.0
+
--- /dev/null
+From 8fd54acc60cb43569c1960a1a7516089379c01a7 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Tue, 24 Nov 2015 11:37:23 -0800
+Subject: [PATCH 11/30] vulkan: Update from version 0.185.0 to 0.186.0
+
+Change-Id: I6acb7742a1d4628930bc0807adfd222bc8349c43
+---
+ vulkan/api/vulkan.api | 12 ++++-----
+ vulkan/include/vulkan/vulkan.h | 53 +++++++++-----------------------------
+ vulkan/libvulkan/entry.cpp | 4 +--
+ vulkan/libvulkan/swapchain.cpp | 4 +--
+ vulkan/nulldrv/null_driver.cpp | 58 ++++++++++++++++--------------------------
+ vulkan/nulldrv/null_driver.h | 2 +-
+ vulkan/tools/vkinfo.cpp | 2 --
+ 7 files changed, 45 insertions(+), 90 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 525b307..bbf9cfe 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 185
++define VERSION_MINOR 186
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -215,6 +215,7 @@ enum VkDescriptorType {
+ enum VkQueryType {
+ VK_QUERY_TYPE_OCCLUSION = 0x00000000,
+ VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001, /// Optional
++ VK_QUERY_TYPE_TIMESTAMP = 0x00000002,
+ }
+
+ enum VkBorderColor {
+@@ -714,7 +715,6 @@ bitfield VkQueueFlagBits {
+ VK_QUEUE_COMPUTE_BIT = 0x00000002, /// Queue supports compute operations
+ VK_QUEUE_DMA_BIT = 0x00000004, /// Queue supports DMA operations
+ VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008, /// Queue supports sparse resource memory management operations
+- VK_QUEUE_EXTENDED_BIT = 0x40000000, /// Extended queue
+ }
+
+ /// Memory properties passed into vkAllocMemory().
+@@ -4320,11 +4320,11 @@ cmd void vkCmdResetQueryPool(
+ cmd void vkCmdWriteTimestamp(
+ VkCmdBuffer cmdBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+- VkBuffer destBuffer,
+- VkDeviceSize destOffset) {
++ VkQueryPool queryPool,
++ u32 slot) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- destBufferObject := GetBuffer(destBuffer)
+- assert(cmdBufferObject.device == destBufferObject.device)
++ queryPoolObject := GetQueryPool(queryPool)
++ assert(cmdBufferObject.device == queryPoolObject.device)
+ }
+
+ @threadSafety("app")
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index c0f3bc7..ca2ff85 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,49 +41,20 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 185, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 186, 0)
+
+
+-#if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
+- #define VK_NULL_HANDLE nullptr
+-#else
+- #define VK_NULL_HANDLE 0
+-#endif
++#define VK_NULL_HANDLE 0
++
+
+
+ #define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj;
+
+
+-#if defined(__cplusplus)
+- #if ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
+- // The bool operator only works if there are no implicit conversions from an obj to
+- // a bool-compatible type, which can then be used to unintentionally violate type safety.
+- // C++11 and above supports the "explicit" keyword on conversion operators to stop this
+- // from happening. Otherwise users of C++ below C++11 won't get direct access to evaluating
+- // the object handle as a bool in expressions like:
+- // if (obj) vkDestroy(obj);
+- #define VK_NONDISP_HANDLE_OPERATOR_BOOL() explicit operator bool() const { return handle != 0; }
+- #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
+- explicit obj(uint64_t x) : handle(x) { } \
+- obj(decltype(nullptr)) : handle(0) { }
+- #else
+- #define VK_NONDISP_HANDLE_OPERATOR_BOOL()
+- #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
+- obj(uint64_t x) : handle(x) { }
+- #endif
+- #define VK_DEFINE_NONDISP_HANDLE(obj) \
+- struct obj { \
+- obj() : handle(0) { } \
+- VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
+- obj& operator =(uint64_t x) { handle = x; return *this; } \
+- bool operator==(const obj& other) const { return handle == other.handle; } \
+- bool operator!=(const obj& other) const { return handle != other.handle; } \
+- bool operator!() const { return !handle; } \
+- VK_NONDISP_HANDLE_OPERATOR_BOOL() \
+- uint64_t handle; \
+- };
++#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
++ #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T *obj;
+ #else
+- #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T { uint64_t handle; } obj;
++ #define VK_DEFINE_NONDISP_HANDLE(obj) typedef uint64_t obj;
+ #endif
+
+
+@@ -441,9 +412,10 @@ typedef enum {
+ typedef enum {
+ VK_QUERY_TYPE_OCCLUSION = 0,
+ VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
++ VK_QUERY_TYPE_TIMESTAMP = 2,
+ VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
+- VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS,
+- VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_PIPELINE_STATISTICS - VK_QUERY_TYPE_OCCLUSION + 1),
++ VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
++ VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
+ VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkQueryType;
+
+@@ -834,7 +806,6 @@ typedef enum {
+ VK_QUEUE_COMPUTE_BIT = 0x00000002,
+ VK_QUEUE_DMA_BIT = 0x00000004,
+ VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008,
+- VK_QUEUE_EXTENDED_BIT = 0x40000000,
+ } VkQueueFlagBits;
+ typedef VkFlags VkQueueFlags;
+
+@@ -2206,7 +2177,7 @@ typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipeline
+ typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+ typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+ typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+-typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset);
++typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
+ typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+ typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
+ typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+@@ -2942,8 +2913,8 @@ void VKAPI vkCmdResetQueryPool(
+ void VKAPI vkCmdWriteTimestamp(
+ VkCmdBuffer cmdBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+- VkBuffer destBuffer,
+- VkDeviceSize destOffset);
++ VkQueryPool queryPool,
++ uint32_t slot);
+
+ void VKAPI vkCmdCopyQueryPoolResults(
+ VkCmdBuffer cmdBuffer,
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index c69b99f..255ad97 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -712,8 +712,8 @@ void vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset) {
+- GetVtbl(cmdBuffer).CmdWriteTimestamp(cmdBuffer, pipelineStage, destBuffer, destOffset);
++void vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
++ GetVtbl(cmdBuffer).CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index 6813680..2922465 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -90,7 +90,7 @@ VkSurfaceKHR HandleFromSurface(Surface* surface) {
+ }
+
+ Surface* SurfaceFromHandle(VkSurfaceKHR handle) {
+- return reinterpret_cast<Surface*>(handle.handle);
++ return reinterpret_cast<Surface*>(handle);
+ }
+
+ struct Swapchain {
+@@ -118,7 +118,7 @@ VkSwapchainKHR HandleFromSwapchain(Swapchain* swapchain) {
+ }
+
+ Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
+- return reinterpret_cast<Swapchain*>(handle.handle);
++ return reinterpret_cast<Swapchain*>(handle);
+ }
+
+ } // anonymous namespace
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 35f2d84..0f8382f 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -199,20 +199,15 @@ uint64_t AllocHandle(VkDevice device, HandleType::Enum type) {
+
+ namespace null_driver {
+
+-template <typename HandleT>
+-struct HandleTraits {};
+-
+-template <typename HandleT>
+-typename HandleTraits<HandleT>::PointerType GetObjectFromHandle(
+- const HandleT& h) {
+- return reinterpret_cast<typename HandleTraits<HandleT>::PointerType>(
+- uintptr_t(h.handle));
+-}
+-
+-template <typename T>
+-typename T::HandleType GetHandleToObject(const T* obj) {
+- return typename T::HandleType(reinterpret_cast<uintptr_t>(obj));
+-}
++#define DEFINE_OBJECT_HANDLE_CONVERSION(T) \
++ T* Get##T##FromHandle(Vk##T h); \
++ T* Get##T##FromHandle(Vk##T h) { \
++ return reinterpret_cast<T*>(uintptr_t(h)); \
++ } \
++ Vk##T GetHandleTo##T(const T* obj); \
++ Vk##T GetHandleTo##T(const T* obj) { \
++ return Vk##T(reinterpret_cast<uintptr_t>(obj)); \
++ }
+
+ // -----------------------------------------------------------------------------
+ // Global
+@@ -384,10 +379,7 @@ struct DeviceMemory {
+ VkDeviceSize size;
+ alignas(16) uint8_t data[0];
+ };
+-template <>
+-struct HandleTraits<VkDeviceMemory> {
+- typedef DeviceMemory* PointerType;
+-};
++DEFINE_OBJECT_HANDLE_CONVERSION(DeviceMemory)
+
+ VkResult AllocMemory(VkDevice device,
+ const VkMemoryAllocInfo* alloc_info,
+@@ -403,13 +395,13 @@ VkResult AllocMemory(VkDevice device,
+ if (!mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ mem->size = size;
+- *mem_handle = GetHandleToObject(mem);
++ *mem_handle = GetHandleToDeviceMemory(mem);
+ return VK_SUCCESS;
+ }
+
+ void FreeMemory(VkDevice device, VkDeviceMemory mem_handle) {
+ const VkAllocCallbacks* alloc = device->instance->alloc;
+- DeviceMemory* mem = GetObjectFromHandle(mem_handle);
++ DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
+ alloc->pfnFree(alloc->pUserData, mem);
+ }
+
+@@ -419,7 +411,7 @@ VkResult MapMemory(VkDevice,
+ VkDeviceSize,
+ VkMemoryMapFlags,
+ void** out_ptr) {
+- DeviceMemory* mem = GetObjectFromHandle(mem_handle);
++ DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
+ *out_ptr = &mem->data[0] + offset;
+ return VK_SUCCESS;
+ }
+@@ -431,10 +423,7 @@ struct Buffer {
+ typedef VkBuffer HandleType;
+ VkDeviceSize size;
+ };
+-template <>
+-struct HandleTraits<VkBuffer> {
+- typedef Buffer* PointerType;
+-};
++DEFINE_OBJECT_HANDLE_CONVERSION(Buffer)
+
+ VkResult CreateBuffer(VkDevice device,
+ const VkBufferCreateInfo* create_info,
+@@ -451,14 +440,14 @@ VkResult CreateBuffer(VkDevice device,
+ if (!buffer)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ buffer->size = create_info->size;
+- *buffer_handle = GetHandleToObject(buffer);
++ *buffer_handle = GetHandleToBuffer(buffer);
+ return VK_SUCCESS;
+ }
+
+ void GetBufferMemoryRequirements(VkDevice,
+ VkBuffer buffer_handle,
+ VkMemoryRequirements* requirements) {
+- Buffer* buffer = GetObjectFromHandle(buffer_handle);
++ Buffer* buffer = GetBufferFromHandle(buffer_handle);
+ requirements->size = buffer->size;
+ requirements->alignment = 16; // allow fast Neon/SSE memcpy
+ requirements->memoryTypeBits = 0x1;
+@@ -466,7 +455,7 @@ void GetBufferMemoryRequirements(VkDevice,
+
+ void DestroyBuffer(VkDevice device, VkBuffer buffer_handle) {
+ const VkAllocCallbacks* alloc = device->instance->alloc;
+- Buffer* buffer = GetObjectFromHandle(buffer_handle);
++ Buffer* buffer = GetBufferFromHandle(buffer_handle);
+ alloc->pfnFree(alloc->pUserData, buffer);
+ }
+
+@@ -477,10 +466,7 @@ struct Image {
+ typedef VkImage HandleType;
+ VkDeviceSize size;
+ };
+-template <>
+-struct HandleTraits<VkImage> {
+- typedef Image* PointerType;
+-};
++DEFINE_OBJECT_HANDLE_CONVERSION(Image)
+
+ VkResult CreateImage(VkDevice device,
+ const VkImageCreateInfo* create_info,
+@@ -509,14 +495,14 @@ VkResult CreateImage(VkDevice device,
+ if (!image)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ image->size = size;
+- *image_handle = GetHandleToObject(image);
++ *image_handle = GetHandleToImage(image);
+ return VK_SUCCESS;
+ }
+
+ void GetImageMemoryRequirements(VkDevice,
+ VkImage image_handle,
+ VkMemoryRequirements* requirements) {
+- Image* image = GetObjectFromHandle(image_handle);
++ Image* image = GetImageFromHandle(image_handle);
+ requirements->size = image->size;
+ requirements->alignment = 16; // allow fast Neon/SSE memcpy
+ requirements->memoryTypeBits = 0x1;
+@@ -524,7 +510,7 @@ void GetImageMemoryRequirements(VkDevice,
+
+ void DestroyImage(VkDevice device, VkImage image_handle) {
+ const VkAllocCallbacks* alloc = device->instance->alloc;
+- Image* image = GetObjectFromHandle(image_handle);
++ Image* image = GetImageFromHandle(image_handle);
+ alloc->pfnFree(alloc->pUserData, image);
+ }
+
+@@ -1031,7 +1017,7 @@ void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
+ void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
+ }
+
+-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset) {
++void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
+ }
+
+ void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index f212371..f07d61c 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -160,7 +160,7 @@ void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask
+ void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+ void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+ void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset);
++void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
+ void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
+ void CmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
+ void CmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
+index 918df47..f92b62c 100644
+--- a/vulkan/tools/vkinfo.cpp
++++ b/vulkan/tools/vkinfo.cpp
+@@ -79,8 +79,6 @@ const char* VkQueueFlagBitStr(VkQueueFlagBits bit) {
+ return "DMA";
+ case VK_QUEUE_SPARSE_MEMMGR_BIT:
+ return "SPARSE";
+- case VK_QUEUE_EXTENDED_BIT:
+- return "EXT";
+ }
+ }
+
+--
+2.4.0
+
--- /dev/null
+From d36b1d2be736d90e71e428b73537cb8d8dea2309 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Tue, 24 Nov 2015 12:44:21 -0800
+Subject: [PATCH 12/30] vulkan: Update from version 0.186.0 to 0.188.0
+
+Change-Id: Ida08d51f4e892202b594072d1e765ba5c55444db
+---
+ vulkan/api/vulkan.api | 314 ++++++++++++++++++------------
+ vulkan/include/vulkan/vulkan.h | 421 ++++++++++++++++++++++++-----------------
+ vulkan/libvulkan/entry.cpp | 256 ++++++++++++-------------
+ vulkan/libvulkan/loader.cpp | 145 +++++++++-----
+ vulkan/libvulkan/loader.h | 7 +-
+ vulkan/libvulkan/swapchain.cpp | 30 ++-
+ vulkan/nulldrv/null_driver.cpp | 211 +++++++++++++--------
+ vulkan/nulldrv/null_driver.h | 88 ++++-----
+ vulkan/tools/vkinfo.cpp | 9 +-
+ 9 files changed, 882 insertions(+), 599 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index bbf9cfe..b95c96e 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 186
++define VERSION_MINOR 188
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -364,12 +364,16 @@ enum VkLogicOp {
+ VK_LOGIC_OP_SET = 0x0000000f,
+ }
+
+-enum VkSystemAllocType {
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0x00000000,
+- VK_SYSTEM_ALLOC_TYPE_INTERNAL = 0x00000001,
+- VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 0x00000002,
+- VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 0x00000003,
+- VK_SYSTEM_ALLOC_TYPE_DEBUG = 0x00000004,
++enum VkSystemAllocScope {
++ VK_SYSTEM_ALLOC_SCOPE_FUNCTION = 0x00000000,
++ VK_SYSTEM_ALLOC_SCOPE_OBJECT = 0x00000001,
++ VK_SYSTEM_ALLOC_SCOPE_CACHE = 0x00000002,
++ VK_SYSTEM_ALLOC_SCOPE_DEVICE = 0x00000003,
++ VK_SYSTEM_ALLOC_SCOPE_INSTANCE = 0x00000004,
++}
++
++enum VkInternalAllocType {
++ VK_INTERNAL_ALLOC_TYPE_EXECUTABLE = 0x00000000,
+ }
+
+ enum VkPhysicalDeviceType {
+@@ -613,6 +617,9 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45,
+ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 47,
++ VK_STRUCTURE_TYPE_SUBMIT_INFO = 48,
++ VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 49,
++ VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 50,
+
+ //@extension("VK_EXT_KHR_swapchain")
+ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 0xc0000801,
+@@ -697,6 +704,7 @@ enum VkPresentModeKHR {
+ VK_PRESENT_MODE_IMMEDIATE_KHR = 0x00000000,
+ VK_PRESENT_MODE_MAILBOX_KHR = 0x00000001,
+ VK_PRESENT_MODE_FIFO_KHR = 0x00000002,
++ VK_PRESENT_MODE_FIFO_RELAXED_KHR = 0x00000003,
+ }
+
+ @extension("VK_EXT_KHR_swapchain")
+@@ -1135,11 +1143,13 @@ class VkLayerProperties {
+ }
+
+ class VkSubmitInfo {
+- u32 waitSemCount
++ VkStructureType sType /// Type of structure. Should be VK_STRUCTURE_TYPE_SUBMIT_INFO
++ const void* pNext /// Next structure in chain
++ u32 waitSemaphoreCount
+ const VkSemaphore* pWaitSemaphores
+- u32 cmdBufferCount
++ u32 commandBufferCount
+ const VkCmdBuffer* pCommandBuffers
+- u32 signalSemCount
++ u32 signalSemaphoreCount
+ const VkSemaphore* pSignalSemaphores
+ }
+
+@@ -1156,14 +1166,17 @@ class VkApplicationInfo {
+ class VkAllocCallbacks {
+ void* pUserData
+ PFN_vkAllocFunction pfnAlloc
++ PFN_vkReallocFunction pfnRealloc
+ PFN_vkFreeFunction pfnFree
++ PFN_vkInternalAllocNotification pfnInternalAlloc
++ PFN_vkInternalFreeNotification pfnInternalFree
+ }
+
+ class VkDeviceQueueCreateInfo {
+ VkStructureType sStype /// Should be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+ u32 queueFamilyIndex
+- u32 queueCount
++ u32 queuePriorityCount
+ const f32* pQueuePriorities
+ }
+
+@@ -1172,9 +1185,9 @@ class VkDeviceCreateInfo {
+ const void* pNext /// Pointer to next structure
+ u32 requestedQueueRecordCount
+ const VkDeviceQueueCreateInfo* pRequestedQueues
+- u32 layerCount
++ u32 enabledLayerNameCount
+ const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled
+- u32 extensionCount
++ u32 enabledExtensionNameCount
+ const char* const* ppEnabledExtensionNames
+ const VkPhysicalDeviceFeatures* pEnabledFeatures
+ }
+@@ -1183,10 +1196,9 @@ class VkInstanceCreateInfo {
+ VkStructureType sType /// Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+ const VkApplicationInfo* pAppInfo
+- const VkAllocCallbacks* pAllocCb
+- u32 layerCount
++ u32 enabledLayerNameCount
+ const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled
+- u32 extensionCount
++ u32 enabledExtensionNameCount
+ const char* const* ppEnabledExtensionNames /// Extension names to be enabled
+ }
+
+@@ -1280,7 +1292,7 @@ class VkWriteDescriptorSet {
+ VkDescriptorSet destSet /// Destination descriptor set
+ u32 destBinding /// Binding within the destination descriptor set to write
+ u32 destArrayElement /// Array element within the destination binding to write
+- u32 count /// Number of descriptors to write (determines the size of the array pointed by <pDescriptors>)
++ u32 descriptorCount /// Number of descriptors to write (determines the size of the array pointed by <pDescriptors>)
+ VkDescriptorType descriptorType /// Descriptor type to write (determines which fields of the array pointed by <pDescriptors> are going to be used)
+ const VkDescriptorImageInfo* pImageInfo
+ const VkDescriptorBufferInfo* pBufferInfo
+@@ -1296,7 +1308,7 @@ class VkCopyDescriptorSet {
+ VkDescriptorSet destSet /// Destination descriptor set
+ u32 destBinding /// Binding within the destination descriptor set to copy to
+ u32 destArrayElement /// Array element within the destination binding to copy to
+- u32 count /// Number of descriptors to copy
++ u32 descriptorCount /// Number of descriptors to copy
+ }
+
+ class VkBufferCreateInfo {
+@@ -1306,7 +1318,7 @@ class VkBufferCreateInfo {
+ VkBufferUsageFlags usage /// Buffer usage flags
+ VkBufferCreateFlags flags /// Buffer creation flags
+ VkSharingMode sharingMode
+- u32 queueFamilyCount
++ u32 queueFamilyIndexCount
+ const u32* pQueueFamilyIndices
+ }
+
+@@ -1378,7 +1390,7 @@ class VkImageCreateInfo {
+ VkImageUsageFlags usage /// Image usage flags
+ VkImageCreateFlags flags /// Image creation flags
+ VkSharingMode sharingMode /// Cross-queue-family sharing mode
+- u32 queueFamilyCount /// Number of queue families to share across
++ u32 queueFamilyIndexCount /// Number of queue families to share across
+ const u32* pQueueFamilyIndices /// Array of queue family indices to share across
+ VkImageLayout initialLayout /// Initial image layout for all subresources
+ }
+@@ -1492,13 +1504,13 @@ class VkDescriptorSetLayoutBinding {
+ class VkDescriptorSetLayoutCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- u32 count /// Number of bindings in the descriptor set layout
+- const VkDescriptorSetLayoutBinding* pBinding /// Array of descriptor set layout bindings
++ u32 bindingCount /// Number of bindings in the descriptor set layout
++ const VkDescriptorSetLayoutBinding* pBindings /// Array of descriptor set layout bindings
+ }
+
+ class VkDescriptorTypeCount {
+ VkDescriptorType type
+- u32 count
++ u32 descriptorCount
+ }
+
+ class VkDescriptorPoolCreateInfo {
+@@ -1506,15 +1518,15 @@ class VkDescriptorPoolCreateInfo {
+ const void* pNext /// Pointer to next structure
+ VkDescriptorPoolCreateFlags flags
+ u32 maxSets
+- u32 count
+- const VkDescriptorTypeCount* pTypeCount
++ u32 typeCount
++ const VkDescriptorTypeCount* pTypeCounts
+ }
+
+ class VkDescriptorSetAllocInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO
+ const void* pNext /// Pointer to next structure
+ VkDescriptorPool descriptorPool
+- u32 count
++ u32 setCount
+ const VkDescriptorSetLayout* pSetLayouts
+ }
+
+@@ -1562,11 +1574,11 @@ class VkVertexInputAttributeDescription {
+ }
+
+ class VkPipelineVertexInputStateCreateInfo {
+- VkStructureType sType /// Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
+- const void* pNext /// Pointer to next structure
+- u32 bindingCount /// number of bindings
++ VkStructureType sType /// Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
++ const void* pNext /// Pointer to next structure
++ u32 vertexBindingDescriptionCount /// number of bindings
+ const VkVertexInputBindingDescription* pVertexBindingDescriptions
+- u32 attributeCount /// number of attributes
++ u32 vertexAttributeDescriptionCount /// number of attributes
+ const VkVertexInputAttributeDescription* pVertexAttributeDescriptions
+ }
+
+@@ -1702,14 +1714,14 @@ class VkPipelineCacheCreateInfo {
+
+ class VkPushConstantRange {
+ VkShaderStageFlags stageFlags /// Which stages use the range
+- u32 start /// Start of the range, in bytes
+- u32 length /// Length of the range, in bytes
++ u32 offset /// Start of the range, in bytes
++ u32 size /// Length of the range, in bytes
+ }
+
+ class VkPipelineLayoutCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- u32 descriptorSetCount /// Number of descriptor sets interfaced by the pipeline
++ u32 setLayoutCount /// Number of descriptor sets interfaced by the pipeline
+ const VkDescriptorSetLayout* pSetLayouts /// Array of <setCount> number of descriptor set layout objects defining the layout of the
+ u32 pushConstantRangeCount /// Number of push-constant ranges used by the pipeline
+ const VkPushConstantRange* pPushConstantRanges /// Array of pushConstantRangeCount number of ranges used by various shader stages
+@@ -1746,7 +1758,7 @@ class VkCmdBufferAllocInfo {
+ const void* pNext /// Pointer to next structure
+ VkCmdPool cmdPool
+ VkCmdBufferLevel level
+- u32 count
++ u32 bufferCount
+ }
+
+ class VkCmdBufferBeginInfo {
+@@ -1818,13 +1830,13 @@ class VkSubpassDescription {
+ const void* pNext /// Pointer to next structure
+ VkPipelineBindPoint pipelineBindPoint /// Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now
+ VkSubpassDescriptionFlags flags
+- u32 inputCount
++ u32 inputAttachmentCount
+ const VkAttachmentReference* pInputAttachments
+- u32 colorCount
++ u32 colorAttachmentCount
+ const VkAttachmentReference* pColorAttachments
+ const VkAttachmentReference* pResolveAttachments
+ VkAttachmentReference depthStencilAttachment
+- u32 preserveCount
++ u32 preserveAttachmentCount
+ const VkAttachmentReference* pPreserveAttachments
+ }
+
+@@ -1879,7 +1891,6 @@ class VkPhysicalDeviceFeatures {
+ VkBool32 fillModeNonSolid /// point and wireframe fill modes
+ VkBool32 depthBounds /// depth bounds test
+ VkBool32 wideLines /// lines with width greater than 1
+- VkBool32 strictLines
+ VkBool32 largePoints /// points with size greater than 1
+ VkBool32 alphaToOne /// The fragment alpha channel can be forced to maximum representable alpha value
+ VkBool32 multiViewport
+@@ -1988,7 +1999,6 @@ class VkPhysicalDeviceLimits {
+
+ u32 maxDrawIndexedIndexValue /// max index value for indexed draw calls (for 32-bit indices)
+ u32 maxDrawIndirectInstanceCount /// max instance count for indirect draw calls
+- VkBool32 primitiveRestartForPatches /// is primitive restart supported for PATCHES
+
+ f32 maxSamplerLodBias /// max absolute sampler level of detail bias
+ f32 maxSamplerAnisotropy /// max degree of sampler anisotropy
+@@ -2037,6 +2047,7 @@ class VkPhysicalDeviceLimits {
+ f32[2] lineWidthRange /// range (min,max) of supported line widths
+ f32 pointSizeGranularity /// granularity of supported point sizes
+ f32 lineWidthGranularity /// granularity of supported line widths
++ VkBool32 strictLines
+
+ u32 recommendedBufferCopyOffsetAlignment
+ u32 recommendedBufferCopyRowPitchAlignment
+@@ -2129,7 +2140,7 @@ class VkSwapchainCreateInfoKHR {
+ VkSurfaceTransformKHR preTransform
+ u32 imageArraySize
+ VkSharingMode sharingMode
+- u32 queueFamilyCount
++ u32 queueFamilyIndexCount
+ const u32* pQueueFamilyIndices
+ VkPresentModeKHR presentMode
+ VkSwapchainKHR oldSwapchain
+@@ -2141,7 +2152,7 @@ class VkPresentInfoKHR {
+ VkStructureType sType
+ const void* pNext
+ u32 swapchainCount
+- const VkSwapchainKHR* swapchains
++ const VkSwapchainKHR* pSwapchains
+ const u32* imageIndices
+ }
+
+@@ -2242,7 +2253,17 @@ class VkDisplayPresentInfoKHR {
+ void* pUserData,
+ platform.size_t size,
+ platform.size_t alignment,
+- VkSystemAllocType allocType) {
++ VkSystemAllocScope allocScope) {
++ return ?
++}
++
++@external type void* PFN_vkReallocFunction
++@pfn cmd void* vkReallocFunction(
++ void* pUserData,
++ void* pOriginal,
++ platform.size_t size,
++ platform.size_t alignment,
++ VkSystemAllocScope allocScope) {
+ return ?
+ }
+
+@@ -2252,12 +2273,28 @@ class VkDisplayPresentInfoKHR {
+ void* pMem) {
+ }
+
++@external type void* PFN_vkInternalAllocNotification
++@pfn cmd void vkInternalAllocNotification(
++ void* pUserData,
++ platform.size_t size,
++ VkInternalAllocType allocType,
++ VkSystemAllocScope allocScope) {
++}
++
++@external type void* PFN_vkInternalFreeNotification
++@pfn cmd void vkInternalFreeNotification(
++ void* pUserData,
++ platform.size_t size,
++ VkInternalAllocType allocType,
++ VkSystemAllocScope allocScope) {
++}
+
+ // Global functions
+
+ @threadSafety("system")
+ cmd VkResult vkCreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkInstance* pInstance) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)
+
+@@ -2265,15 +2302,16 @@ cmd VkResult vkCreateInstance(
+ pInstance[0] = instance
+ State.Instances[instance] = new!InstanceObject()
+
+- layers := pCreateInfo.ppEnabledLayerNames[0:pCreateInfo.layerCount]
+- extensions := pCreateInfo.ppEnabledExtensionNames[0:pCreateInfo.extensionCount]
++ layers := pCreateInfo.ppEnabledLayerNames[0:pCreateInfo.enabledLayerNameCount]
++ extensions := pCreateInfo.ppEnabledExtensionNames[0:pCreateInfo.enabledExtensionNameCount]
+
+ return ?
+ }
+
+ @threadSafety("system")
+ cmd void vkDestroyInstance(
+- VkInstance instance) {
++ VkInstance instance,
++ const VkAllocCallbacks* pAllocator) {
+ instanceObject := GetInstance(instance)
+
+ State.Instances[instance] = null
+@@ -2332,7 +2370,7 @@ cmd void vkGetPhysicalDeviceProperties(
+
+ cmd void vkGetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice physicalDevice,
+- u32* pCount,
++ u32* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+ // TODO: Figure out how to express fetch-count-or-properties
+@@ -2400,6 +2438,7 @@ cmd void vkGetPhysicalDeviceImageFormatProperties(
+ cmd VkResult vkCreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkDevice* pDevice) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+@@ -2413,7 +2452,8 @@ cmd VkResult vkCreateDevice(
+
+ @threadSafety("system")
+ cmd void vkDestroyDevice(
+- VkDevice device) {
++ VkDevice device,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+
+ State.Devices[device] = null
+@@ -2423,10 +2463,10 @@ cmd void vkDestroyDevice(
+ // Extension discovery functions
+
+ cmd VkResult vkEnumerateInstanceLayerProperties(
+- u32* pCount,
++ u32* pPropertyCount,
+ VkLayerProperties* pProperties) {
+ count := as!u32(?)
+- pCount[0] = count
++ pPropertyCount[0] = count
+
+ properties := pProperties[0:count]
+ for i in (0 .. count) {
+@@ -2439,10 +2479,10 @@ cmd VkResult vkEnumerateInstanceLayerProperties(
+
+ cmd VkResult vkEnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+- u32* pCount,
++ u32* pPropertyCount,
+ VkExtensionProperties* pProperties) {
+ count := as!u32(?)
+- pCount[0] = count
++ pPropertyCount[0] = count
+
+ properties := pProperties[0:count]
+ for i in (0 .. count) {
+@@ -2455,11 +2495,11 @@ cmd VkResult vkEnumerateInstanceExtensionProperties(
+
+ cmd VkResult vkEnumerateDeviceLayerProperties(
+ VkPhysicalDevice physicalDevice,
+- u32* pCount,
++ u32* pPropertyCount,
+ VkLayerProperties* pProperties) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+ count := as!u32(?)
+- pCount[0] = count
++ pPropertyCount[0] = count
+
+ properties := pProperties[0:count]
+ for i in (0 .. count) {
+@@ -2473,12 +2513,12 @@ cmd VkResult vkEnumerateDeviceLayerProperties(
+ cmd VkResult vkEnumerateDeviceExtensionProperties(
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+- u32* pCount,
++ u32* pPropertyCount,
+ VkExtensionProperties* pProperties) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+
+ count := as!u32(?)
+- pCount[0] = count
++ pPropertyCount[0] = count
+
+ properties := pProperties[0:count]
+ for i in (0 .. count) {
+@@ -2557,6 +2597,7 @@ cmd VkResult vkDeviceWaitIdle(
+ cmd VkResult vkAllocMemory(
+ VkDevice device,
+ const VkMemoryAllocInfo* pAllocInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkDeviceMemory* pMem) {
+ assert(pAllocInfo.sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO)
+ deviceObject := GetDevice(device)
+@@ -2573,7 +2614,8 @@ cmd VkResult vkAllocMemory(
+ @threadSafety("system")
+ cmd void vkFreeMemory(
+ VkDevice device,
+- VkDeviceMemory mem) {
++ VkDeviceMemory mem,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ memObject := GetDeviceMemory(mem)
+ assert(memObject.device == device)
+@@ -2740,7 +2782,7 @@ cmd VkResult vkBindImageMemory(
+ cmd void vkGetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+- u32* pNumRequirements,
++ u32* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+ deviceObject := GetDevice(device)
+ imageObject := GetImage(image)
+@@ -2754,7 +2796,7 @@ cmd void vkGetPhysicalDeviceSparseImageFormatProperties(
+ u32 samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+- u32* pNumProperties,
++ u32* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+ }
+@@ -2762,7 +2804,7 @@ cmd void vkGetPhysicalDeviceSparseImageFormatProperties(
+ cmd VkResult vkQueueBindSparseBufferMemory(
+ VkQueue queue,
+ VkBuffer buffer,
+- u32 numBindings,
++ u32 bindInfoCount,
+ const VkSparseMemoryBindInfo* pBindInfo) {
+ queueObject := GetQueue(queue)
+ bufferObject := GetBuffer(buffer)
+@@ -2774,7 +2816,7 @@ cmd VkResult vkQueueBindSparseBufferMemory(
+ cmd VkResult vkQueueBindSparseImageOpaqueMemory(
+ VkQueue queue,
+ VkImage image,
+- u32 numBindings,
++ u32 bindInfoCount,
+ const VkSparseMemoryBindInfo* pBindInfo) {
+ queueObject := GetQueue(queue)
+ imageObject := GetImage(image)
+@@ -2783,11 +2825,10 @@ cmd VkResult vkQueueBindSparseImageOpaqueMemory(
+ return ?
+ }
+
+-
+ cmd VkResult vkQueueBindSparseImageMemory(
+ VkQueue queue,
+ VkImage image,
+- u32 numBindings,
++ u32 bindInfoCount,
+ const VkSparseImageMemoryBindInfo* pBindInfo) {
+ queueObject := GetQueue(queue)
+ imageObject := GetImage(image)
+@@ -2802,6 +2843,7 @@ cmd VkResult vkQueueBindSparseImageMemory(
+ cmd VkResult vkCreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkFence* pFence) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -2817,7 +2859,8 @@ cmd VkResult vkCreateFence(
+ @threadSafety("system")
+ cmd void vkDestroyFence(
+ VkDevice device,
+- VkFence fence) {
++ VkFence fence,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ fenceObject := GetFence(fence)
+ assert(fenceObject.device == device)
+@@ -2880,6 +2923,7 @@ cmd VkResult vkWaitForFences(
+ cmd VkResult vkCreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkSemaphore* pSemaphore) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -2894,7 +2938,8 @@ cmd VkResult vkCreateSemaphore(
+ @threadSafety("system")
+ cmd void vkDestroySemaphore(
+ VkDevice device,
+- VkSemaphore semaphore) {
++ VkSemaphore semaphore,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ semaphoreObject := GetSemaphore(semaphore)
+ assert(semaphoreObject.device == device)
+@@ -2909,6 +2954,7 @@ cmd void vkDestroySemaphore(
+ cmd VkResult vkCreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkEvent* pEvent) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -2923,7 +2969,8 @@ cmd VkResult vkCreateEvent(
+ @threadSafety("system")
+ cmd void vkDestroyEvent(
+ VkDevice device,
+- VkEvent event) {
++ VkEvent event,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ eventObject := GetEvent(event)
+ assert(eventObject.device == device)
+@@ -2971,6 +3018,7 @@ cmd VkResult vkResetEvent(
+ cmd VkResult vkCreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkQueryPool* pQueryPool) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -2985,7 +3033,8 @@ cmd VkResult vkCreateQueryPool(
+ @threadSafety("system")
+ cmd void vkDestroyQueryPool(
+ VkDevice device,
+- VkQueryPool queryPool) {
++ VkQueryPool queryPool,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ queryPoolObject := GetQueryPool(queryPool)
+ assert(queryPoolObject.device == device)
+@@ -3018,6 +3067,7 @@ cmd VkResult vkGetQueryPoolResults(
+ cmd VkResult vkCreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkBuffer* pBuffer) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3032,7 +3082,8 @@ cmd VkResult vkCreateBuffer(
+ @threadSafety("system")
+ cmd void vkDestroyBuffer(
+ VkDevice device,
+- VkBuffer buffer) {
++ VkBuffer buffer,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ bufferObject := GetBuffer(buffer)
+ assert(bufferObject.device == device)
+@@ -3048,6 +3099,7 @@ cmd void vkDestroyBuffer(
+ cmd VkResult vkCreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkBufferView* pView) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3065,7 +3117,8 @@ cmd VkResult vkCreateBufferView(
+ @threadSafety("system")
+ cmd void vkDestroyBufferView(
+ VkDevice device,
+- VkBufferView bufferView) {
++ VkBufferView bufferView,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ bufferViewObject := GetBufferView(bufferView)
+ assert(bufferViewObject.device == device)
+@@ -3080,6 +3133,7 @@ cmd void vkDestroyBufferView(
+ cmd VkResult vkCreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkImage* pImage) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3094,7 +3148,8 @@ cmd VkResult vkCreateImage(
+ @threadSafety("system")
+ cmd void vkDestroyImage(
+ VkDevice device,
+- VkImage image) {
++ VkImage image,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ imageObject := GetImage(image)
+ assert(imageObject.device == device)
+@@ -3120,6 +3175,7 @@ cmd void vkGetImageSubresourceLayout(
+ cmd VkResult vkCreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkImageView* pView) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3137,7 +3193,8 @@ cmd VkResult vkCreateImageView(
+ @threadSafety("system")
+ cmd void vkDestroyImageView(
+ VkDevice device,
+- VkImageView imageView) {
++ VkImageView imageView,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ imageViewObject := GetImageView(imageView)
+ assert(imageViewObject.device == device)
+@@ -3151,6 +3208,7 @@ cmd void vkDestroyImageView(
+ cmd VkResult vkCreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkShaderModule* pShaderModule) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3164,7 +3222,8 @@ cmd VkResult vkCreateShaderModule(
+
+ cmd void vkDestroyShaderModule(
+ VkDevice device,
+- VkShaderModule shaderModule) {
++ VkShaderModule shaderModule,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ shaderModuleObject := GetShaderModule(shaderModule)
+ assert(shaderModuleObject.device == device)
+@@ -3176,6 +3235,7 @@ cmd void vkDestroyShaderModule(
+ cmd VkResult vkCreateShader(
+ VkDevice device,
+ const VkShaderCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkShader* pShader) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3190,7 +3250,8 @@ cmd VkResult vkCreateShader(
+ @threadSafety("system")
+ cmd void vkDestroyShader(
+ VkDevice device,
+- VkShader shader) {
++ VkShader shader,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ shaderObject := GetShader(shader)
+ assert(shaderObject.device == device)
+@@ -3204,6 +3265,7 @@ cmd void vkDestroyShader(
+ cmd VkResult vkCreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3217,7 +3279,8 @@ cmd VkResult vkCreatePipelineCache(
+
+ cmd void vkDestroyPipelineCache(
+ VkDevice device,
+- VkPipelineCache pipelineCache) {
++ VkPipelineCache pipelineCache,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ pipelineCacheObject := GetPipelineCache(pipelineCache)
+ assert(pipelineCacheObject.device == device)
+@@ -3259,8 +3322,9 @@ cmd VkResult vkMergePipelineCaches(
+ cmd VkResult vkCreateGraphicsPipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+- u32 count,
++ u32 createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
++ const VkAllocCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
+ deviceObject := GetDevice(device)
+ if pipelineCache != NULL_HANDLE {
+@@ -3268,9 +3332,9 @@ cmd VkResult vkCreateGraphicsPipelines(
+ assert(pipelineCacheObject.device == device)
+ }
+
+- createInfos := pCreateInfos[0:count]
+- pipelines := pPipelines[0:count]
+- for i in (0 .. count) {
++ createInfos := pCreateInfos[0:createInfoCount]
++ pipelines := pPipelines[0:createInfoCount]
++ for i in (0 .. createInfoCount) {
+ pipeline := ?
+ pipelines[i] = pipeline
+ State.Pipelines[pipeline] = new!PipelineObject(device: device)
+@@ -3282,8 +3346,9 @@ cmd VkResult vkCreateGraphicsPipelines(
+ cmd VkResult vkCreateComputePipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+- u32 count,
++ u32 createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
++ const VkAllocCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
+ deviceObject := GetDevice(device)
+ if pipelineCache != NULL_HANDLE {
+@@ -3291,9 +3356,9 @@ cmd VkResult vkCreateComputePipelines(
+ assert(pipelineCacheObject.device == device)
+ }
+
+- createInfos := pCreateInfos[0:count]
+- pipelines := pPipelines[0:count]
+- for i in (0 .. count) {
++ createInfos := pCreateInfos[0:createInfoCount]
++ pipelines := pPipelines[0:createInfoCount]
++ for i in (0 .. createInfoCount) {
+ pipeline := ?
+ pipelines[i] = pipeline
+ State.Pipelines[pipeline] = new!PipelineObject(device: device)
+@@ -3305,7 +3370,8 @@ cmd VkResult vkCreateComputePipelines(
+ @threadSafety("system")
+ cmd void vkDestroyPipeline(
+ VkDevice device,
+- VkPipeline pipeline) {
++ VkPipeline pipeline,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ pipelineObjects := GetPipeline(pipeline)
+ assert(pipelineObjects.device == device)
+@@ -3320,6 +3386,7 @@ cmd void vkDestroyPipeline(
+ cmd VkResult vkCreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3334,7 +3401,8 @@ cmd VkResult vkCreatePipelineLayout(
+ @threadSafety("system")
+ cmd void vkDestroyPipelineLayout(
+ VkDevice device,
+- VkPipelineLayout pipelineLayout) {
++ VkPipelineLayout pipelineLayout,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ pipelineLayoutObjects := GetPipelineLayout(pipelineLayout)
+ assert(pipelineLayoutObjects.device == device)
+@@ -3349,6 +3417,7 @@ cmd void vkDestroyPipelineLayout(
+ cmd VkResult vkCreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkSampler* pSampler) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3363,7 +3432,8 @@ cmd VkResult vkCreateSampler(
+ @threadSafety("system")
+ cmd void vkDestroySampler(
+ VkDevice device,
+- VkSampler sampler) {
++ VkSampler sampler,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ samplerObject := GetSampler(sampler)
+ assert(samplerObject.device == device)
+@@ -3378,6 +3448,7 @@ cmd void vkDestroySampler(
+ cmd VkResult vkCreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3392,7 +3463,8 @@ cmd VkResult vkCreateDescriptorSetLayout(
+ @threadSafety("system")
+ cmd void vkDestroyDescriptorSetLayout(
+ VkDevice device,
+- VkDescriptorSetLayout descriptorSetLayout) {
++ VkDescriptorSetLayout descriptorSetLayout,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ descriptorSetLayoutObject := GetDescriptorSetLayout(descriptorSetLayout)
+ assert(descriptorSetLayoutObject.device == device)
+@@ -3403,7 +3475,8 @@ cmd void vkDestroyDescriptorSetLayout(
+ @threadSafety("system")
+ cmd VkResult vkCreateDescriptorPool(
+ VkDevice device,
+- const VkDescriptorPoolCreateInfo* pCreateInfo
++ const VkDescriptorPoolCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3418,7 +3491,8 @@ cmd VkResult vkCreateDescriptorPool(
+ @threadSafety("system")
+ cmd void vkDestroyDescriptorPool(
+ VkDevice device,
+- VkDescriptorPool descriptorPool) {
++ VkDescriptorPool descriptorPool,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ descriptorPoolObject := GetDescriptorPool(descriptorPool)
+ assert(descriptorPoolObject.device == device)
+@@ -3447,15 +3521,15 @@ cmd VkResult vkAllocDescriptorSets(
+ allocInfo := pAllocInfo[0]
+ descriptorPoolObject := GetDescriptorPool(allocInfo.descriptorPool)
+
+- setLayouts := allocInfo.pSetLayouts[0:allocInfo.count]
+- for i in (0 .. allocInfo.count) {
++ setLayouts := allocInfo.pSetLayouts[0:allocInfo.setCount]
++ for i in (0 .. allocInfo.setCount) {
+ setLayout := setLayouts[i]
+ setLayoutObject := GetDescriptorSetLayout(setLayout)
+ assert(setLayoutObject.device == device)
+ }
+
+- descriptorSets := pDescriptorSets[0:allocInfo.count]
+- for i in (0 .. allocInfo.count) {
++ descriptorSets := pDescriptorSets[0:allocInfo.setCount]
++ for i in (0 .. allocInfo.setCount) {
+ descriptorSet := ?
+ descriptorSets[i] = descriptorSet
+ State.DescriptorSets[descriptorSet] = new!DescriptorSetObject(device: device)
+@@ -3467,13 +3541,13 @@ cmd VkResult vkAllocDescriptorSets(
+ cmd VkResult vkFreeDescriptorSets(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+- u32 count,
++ u32 descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets) {
+ deviceObject := GetDevice(device)
+ descriptorPoolObject := GetDescriptorPool(descriptorPool)
+
+- descriptorSets := pDescriptorSets[0:count]
+- for i in (0 .. count) {
++ descriptorSets := pDescriptorSets[0:descriptorSetCount]
++ for i in (0 .. descriptorSetCount) {
+ descriptorSet := descriptorSets[i]
+ descriptorSetObject := GetDescriptorSet(descriptorSet)
+ assert(descriptorSetObject.device == device)
+@@ -3513,6 +3587,7 @@ cmd void vkUpdateDescriptorSets(
+ cmd VkResult vkCreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3527,7 +3602,8 @@ cmd VkResult vkCreateFramebuffer(
+ @threadSafety("system")
+ cmd void vkDestroyFramebuffer(
+ VkDevice device,
+- VkFramebuffer framebuffer) {
++ VkFramebuffer framebuffer,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ framebufferObject := GetFramebuffer(framebuffer)
+ assert(framebufferObject.device == device)
+@@ -3542,6 +3618,7 @@ cmd void vkDestroyFramebuffer(
+ cmd VkResult vkCreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3556,7 +3633,8 @@ cmd VkResult vkCreateRenderPass(
+ @threadSafety("system")
+ cmd void vkDestroyRenderPass(
+ VkDevice device,
+- VkRenderPass renderPass) {
++ VkRenderPass renderPass,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ renderPassObject := GetRenderPass(renderPass)
+ assert(renderPassObject.device == device)
+@@ -3580,6 +3658,7 @@ cmd void vkGetRenderAreaGranularity(
+ cmd VkResult vkCreateCommandPool(
+ VkDevice device,
+ const VkCmdPoolCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkCmdPool* pCmdPool) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3593,7 +3672,8 @@ cmd VkResult vkCreateCommandPool(
+
+ cmd void vkDestroyCommandPool(
+ VkDevice device,
+- VkCmdPool cmdPool) {
++ VkCmdPool cmdPool,
++ const VkAllocCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ cmdPoolObject := GetCmdPool(cmdPool)
+ assert(cmdPoolObject.device == device)
+@@ -3637,7 +3717,7 @@ cmd VkResult vkAllocCommandBuffers(
+ VkCmdBuffer* pCmdBuffers) {
+ assert(pAllocInfo[0].sType == VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO)
+
+- count := pAllocInfo[0].count
++ count := pAllocInfo[0].bufferCount
+ cmdBuffers := pCmdBuffers[0:count]
+ for i in (0 .. count) {
+ cmdBuffer := ?
+@@ -3652,12 +3732,12 @@ cmd VkResult vkAllocCommandBuffers(
+ cmd void vkFreeCommandBuffers(
+ VkDevice device,
+ VkCmdPool cmdPool,
+- u32 count,
++ u32 commandBufferCount,
+ const VkCmdBuffer* pCommandBuffers) {
+ deviceObject := GetDevice(device)
+
+- cmdBuffers := pCommandBuffers[0:count]
+- for i in (0 .. count) {
++ cmdBuffers := pCommandBuffers[0:commandBufferCount]
++ for i in (0 .. commandBufferCount) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffers[i])
+ assert(cmdBufferObject.device == device)
+ // TODO: iterate over boundObjects and clear memory bindings
+@@ -3804,14 +3884,14 @@ cmd void vkCmdBindDescriptorSets(
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ u32 firstSet,
+- u32 setCount,
++ u32 descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ u32 dynamicOffsetCount,
+ const u32* pDynamicOffsets) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+
+- descriptorSets := pDescriptorSets[0:setCount]
+- for i in (0 .. setCount) {
++ descriptorSets := pDescriptorSets[0:descriptorSetCount]
++ for i in (0 .. descriptorSetCount) {
+ descriptorSet := descriptorSets[i]
+ descriptorSetObject := GetDescriptorSet(descriptorSet)
+ assert(cmdBufferObject.device == descriptorSetObject.device)
+@@ -3898,7 +3978,7 @@ cmd void vkCmdDrawIndirect(
+ VkCmdBuffer cmdBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+- u32 count,
++ u32 drawCount,
+ u32 stride) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ bufferObject := GetBuffer(buffer)
+@@ -3914,7 +3994,7 @@ cmd void vkCmdDrawIndexedIndirect(
+ VkCmdBuffer cmdBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+- u32 count,
++ u32 drawCount,
+ u32 stride) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ bufferObject := GetBuffer(buffer)
+@@ -4348,8 +4428,8 @@ cmd void vkCmdPushConstants(
+ VkCmdBuffer cmdBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+- u32 start,
+- u32 length,
++ u32 offset,
++ u32 size,
+ const void* values) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ layoutObject := GetPipelineLayout(layout)
+@@ -4438,12 +4518,12 @@ cmd VkResult vkGetSurfacePropertiesKHR(
+ cmd VkResult vkGetSurfaceFormatsKHR(
+ VkDevice device,
+ VkSurfaceKHR surface,
+- u32* pCount,
++ u32* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats) {
+ deviceObject := GetDevice(device)
+
+ count := as!u32(?)
+- pCount[0] = count
++ pSurfaceFormatCount[0] = count
+ surfaceFormats := pSurfaceFormats[0:count]
+
+ for i in (0 .. count) {
+@@ -4458,12 +4538,12 @@ cmd VkResult vkGetSurfaceFormatsKHR(
+ cmd VkResult vkGetSurfacePresentModesKHR(
+ VkDevice device,
+ VkSurfaceKHR surface,
+- u32* pCount,
++ u32* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes) {
+ deviceObject := GetDevice(device)
+
+ count := as!u32(?)
+- pCount[0] = count
++ pPresentModeCount[0] = count
+ presentModes := pPresentModes[0:count]
+
+ for i in (0 .. count) {
+@@ -4504,12 +4584,12 @@ cmd void vkDestroySwapchainKHR(
+ cmd VkResult vkGetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+- u32* pCount,
++ u32* pSwapchainImageCount,
+ VkImage* pSwapchainImages) {
+ deviceObject := GetDevice(device)
+
+ count := as!u32(?)
+- pCount[0] = count
++ pSwapchainImageCount[0] = count
+ swapchainImages := pSwapchainImages[0:count]
+
+ for i in (0 .. count) {
+@@ -4553,7 +4633,7 @@ cmd VkResult vkQueuePresentKHR(
+ @extension("VK_EXT_KHR_display")
+ cmd VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+- u32* count,
++ u32* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+ return ?
+@@ -4563,8 +4643,8 @@ cmd VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
+ cmd VkResult vkGetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+- u32* pCount,
+- VkDisplayModePropertiesKHR* pModeProperties) {
++ u32* pPropertyCount,
++ VkDisplayModePropertiesKHR* pProperties) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+ return ?
+ }
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index ca2ff85..d061988 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 186, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 188, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -179,23 +179,34 @@ typedef enum {
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45,
+ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 47,
++ VK_STRUCTURE_TYPE_SUBMIT_INFO = 48,
++ VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 49,
++ VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 50,
+ VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+- VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO,
+- VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
++ VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO,
++ VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+ VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkStructureType;
+
+ typedef enum {
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0,
+- VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1,
+- VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2,
+- VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3,
+- VK_SYSTEM_ALLOC_TYPE_DEBUG = 4,
+- VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT,
+- VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG,
+- VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1),
+- VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF
+-} VkSystemAllocType;
++ VK_SYSTEM_ALLOC_SCOPE_FUNCTION = 0,
++ VK_SYSTEM_ALLOC_SCOPE_OBJECT = 1,
++ VK_SYSTEM_ALLOC_SCOPE_CACHE = 2,
++ VK_SYSTEM_ALLOC_SCOPE_DEVICE = 3,
++ VK_SYSTEM_ALLOC_SCOPE_INSTANCE = 4,
++ VK_SYSTEM_ALLOC_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_SCOPE_FUNCTION,
++ VK_SYSTEM_ALLOC_SCOPE_END_RANGE = VK_SYSTEM_ALLOC_SCOPE_INSTANCE,
++ VK_SYSTEM_ALLOC_SCOPE_NUM = (VK_SYSTEM_ALLOC_SCOPE_INSTANCE - VK_SYSTEM_ALLOC_SCOPE_FUNCTION + 1),
++ VK_SYSTEM_ALLOC_SCOPE_MAX_ENUM = 0x7FFFFFFF
++} VkSystemAllocScope;
++
++typedef enum {
++ VK_INTERNAL_ALLOC_TYPE_EXECUTABLE = 0,
++ VK_INTERNAL_ALLOC_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOC_TYPE_EXECUTABLE,
++ VK_INTERNAL_ALLOC_TYPE_END_RANGE = VK_INTERNAL_ALLOC_TYPE_EXECUTABLE,
++ VK_INTERNAL_ALLOC_TYPE_NUM = (VK_INTERNAL_ALLOC_TYPE_EXECUTABLE - VK_INTERNAL_ALLOC_TYPE_EXECUTABLE + 1),
++ VK_INTERNAL_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF
++} VkInternalAllocType;
+
+ typedef enum {
+ VK_FORMAT_UNDEFINED = 0,
+@@ -1020,15 +1031,34 @@ typedef enum {
+ typedef VkFlags VkQueryControlFlags;
+
+ typedef void* (VKAPI *PFN_vkAllocFunction)(
+- void* pUserData,
+- size_t size,
+- size_t alignment,
+- VkSystemAllocType allocType);
++ void* pUserData,
++ size_t size,
++ size_t alignment,
++ VkSystemAllocScope allocScope);
++
++typedef void* (VKAPI *PFN_vkReallocFunction)(
++ void* pUserData,
++ void* pOriginal,
++ size_t size,
++ size_t alignment,
++ VkSystemAllocScope allocScope);
+
+ typedef void (VKAPI *PFN_vkFreeFunction)(
+ void* pUserData,
+ void* pMem);
+
++typedef void (VKAPI *PFN_vkInternalAllocNotification)(
++ void* pUserData,
++ size_t size,
++ VkInternalAllocType allocType,
++ VkSystemAllocScope allocScope);
++
++typedef void (VKAPI *PFN_vkInternalFreeNotification)(
++ void* pUserData,
++ size_t size,
++ VkInternalAllocType allocType,
++ VkSystemAllocScope allocScope);
++
+ typedef void (VKAPI *PFN_vkVoidFunction)(void);
+
+ typedef struct {
+@@ -1042,23 +1072,25 @@ typedef struct {
+ } VkApplicationInfo;
+
+ typedef struct {
+- void* pUserData;
+- PFN_vkAllocFunction pfnAlloc;
+- PFN_vkFreeFunction pfnFree;
+-} VkAllocCallbacks;
+-
+-typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ const VkApplicationInfo* pAppInfo;
+- const VkAllocCallbacks* pAllocCb;
+- uint32_t layerCount;
++ uint32_t enabledLayerNameCount;
+ const char*const* ppEnabledLayerNames;
+- uint32_t extensionCount;
++ uint32_t enabledExtensionNameCount;
+ const char*const* ppEnabledExtensionNames;
+ } VkInstanceCreateInfo;
+
+ typedef struct {
++ void* pUserData;
++ PFN_vkAllocFunction pfnAlloc;
++ PFN_vkReallocFunction pfnRealloc;
++ PFN_vkFreeFunction pfnFree;
++ PFN_vkInternalAllocNotification pfnInternalAlloc;
++ PFN_vkInternalFreeNotification pfnInternalFree;
++} VkAllocCallbacks;
++
++typedef struct {
+ VkBool32 robustBufferAccess;
+ VkBool32 fullDrawIndexUint32;
+ VkBool32 imageCubeArray;
+@@ -1074,7 +1106,6 @@ typedef struct {
+ VkBool32 fillModeNonSolid;
+ VkBool32 depthBounds;
+ VkBool32 wideLines;
+- VkBool32 strictLines;
+ VkBool32 largePoints;
+ VkBool32 alphaToOne;
+ VkBool32 multiViewport;
+@@ -1193,7 +1224,6 @@ typedef struct {
+ uint32_t mipmapPrecisionBits;
+ uint32_t maxDrawIndexedIndexValue;
+ uint32_t maxDrawIndirectInstanceCount;
+- VkBool32 primitiveRestartForPatches;
+ float maxSamplerLodBias;
+ float maxSamplerAnisotropy;
+ uint32_t maxViewports;
+@@ -1232,6 +1262,7 @@ typedef struct {
+ float lineWidthRange[2];
+ float pointSizeGranularity;
+ float lineWidthGranularity;
++ VkBool32 strictLines;
+ uint32_t recommendedBufferCopyOffsetAlignment;
+ uint32_t recommendedBufferCopyRowPitchAlignment;
+ } VkPhysicalDeviceLimits;
+@@ -1284,7 +1315,7 @@ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t queueFamilyIndex;
+- uint32_t queueCount;
++ uint32_t queuePriorityCount;
+ const float* pQueuePriorities;
+ } VkDeviceQueueCreateInfo;
+
+@@ -1293,9 +1324,9 @@ typedef struct {
+ const void* pNext;
+ uint32_t requestedQueueCount;
+ const VkDeviceQueueCreateInfo* pRequestedQueues;
+- uint32_t layerCount;
++ uint32_t enabledLayerNameCount;
+ const char*const* ppEnabledLayerNames;
+- uint32_t extensionCount;
++ uint32_t enabledExtensionNameCount;
+ const char*const* ppEnabledExtensionNames;
+ const VkPhysicalDeviceFeatures* pEnabledFeatures;
+ } VkDeviceCreateInfo;
+@@ -1313,11 +1344,13 @@ typedef struct {
+ } VkLayerProperties;
+
+ typedef struct {
+- uint32_t waitSemCount;
++ VkStructureType sType;
++ const void* pNext;
++ uint32_t waitSemaphoreCount;
+ const VkSemaphore* pWaitSemaphores;
+- uint32_t cmdBufferCount;
++ uint32_t commandBufferCount;
+ const VkCmdBuffer* pCommandBuffers;
+- uint32_t signalSemCount;
++ uint32_t signalSemaphoreCount;
+ const VkSemaphore* pSignalSemaphores;
+ } VkSubmitInfo;
+
+@@ -1418,7 +1451,7 @@ typedef struct {
+ VkBufferUsageFlags usage;
+ VkBufferCreateFlags flags;
+ VkSharingMode sharingMode;
+- uint32_t queueFamilyCount;
++ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ } VkBufferCreateInfo;
+
+@@ -1444,7 +1477,7 @@ typedef struct {
+ VkImageUsageFlags usage;
+ VkImageCreateFlags flags;
+ VkSharingMode sharingMode;
+- uint32_t queueFamilyCount;
++ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ VkImageLayout initialLayout;
+ } VkImageCreateInfo;
+@@ -1543,9 +1576,9 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- uint32_t bindingCount;
++ uint32_t vertexBindingDescriptionCount;
+ const VkVertexInputBindingDescription* pVertexBindingDescriptions;
+- uint32_t attributeCount;
++ uint32_t vertexAttributeDescriptionCount;
+ const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
+ } VkPipelineVertexInputStateCreateInfo;
+
+@@ -1707,14 +1740,14 @@ typedef struct {
+
+ typedef struct {
+ VkShaderStageFlags stageFlags;
+- uint32_t start;
+- uint32_t length;
++ uint32_t offset;
++ uint32_t size;
+ } VkPushConstantRange;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- uint32_t descriptorSetCount;
++ uint32_t setLayoutCount;
+ const VkDescriptorSetLayout* pSetLayouts;
+ uint32_t pushConstantRangeCount;
+ const VkPushConstantRange* pPushConstantRanges;
+@@ -1749,13 +1782,13 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- uint32_t count;
+- const VkDescriptorSetLayoutBinding* pBinding;
++ uint32_t bindingCount;
++ const VkDescriptorSetLayoutBinding* pBindings;
+ } VkDescriptorSetLayoutCreateInfo;
+
+ typedef struct {
+ VkDescriptorType type;
+- uint32_t count;
++ uint32_t descriptorCount;
+ } VkDescriptorTypeCount;
+
+ typedef struct {
+@@ -1763,15 +1796,15 @@ typedef struct {
+ const void* pNext;
+ VkDescriptorPoolCreateFlags flags;
+ uint32_t maxSets;
+- uint32_t count;
+- const VkDescriptorTypeCount* pTypeCount;
++ uint32_t typeCount;
++ const VkDescriptorTypeCount* pTypeCounts;
+ } VkDescriptorPoolCreateInfo;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorPool descriptorPool;
+- uint32_t count;
++ uint32_t setLayoutCount;
+ const VkDescriptorSetLayout* pSetLayouts;
+ } VkDescriptorSetAllocInfo;
+
+@@ -1793,7 +1826,7 @@ typedef struct {
+ VkDescriptorSet destSet;
+ uint32_t destBinding;
+ uint32_t destArrayElement;
+- uint32_t count;
++ uint32_t descriptorCount;
+ VkDescriptorType descriptorType;
+ const VkDescriptorImageInfo* pImageInfo;
+ const VkDescriptorBufferInfo* pBufferInfo;
+@@ -1809,7 +1842,7 @@ typedef struct {
+ VkDescriptorSet destSet;
+ uint32_t destBinding;
+ uint32_t destArrayElement;
+- uint32_t count;
++ uint32_t descriptorCount;
+ } VkCopyDescriptorSet;
+
+ typedef struct {
+@@ -1847,13 +1880,13 @@ typedef struct {
+ const void* pNext;
+ VkPipelineBindPoint pipelineBindPoint;
+ VkSubpassDescriptionFlags flags;
+- uint32_t inputCount;
++ uint32_t inputAttachmentCount;
+ const VkAttachmentReference* pInputAttachments;
+- uint32_t colorCount;
++ uint32_t colorAttachmentCount;
+ const VkAttachmentReference* pColorAttachments;
+ const VkAttachmentReference* pResolveAttachments;
+ VkAttachmentReference depthStencilAttachment;
+- uint32_t preserveCount;
++ uint32_t preserveAttachmentCount;
+ const VkAttachmentReference* pPreserveAttachments;
+ } VkSubpassDescription;
+
+@@ -1892,7 +1925,7 @@ typedef struct {
+ const void* pNext;
+ VkCmdPool cmdPool;
+ VkCmdBufferLevel level;
+- uint32_t count;
++ uint32_t bufferCount;
+ } VkCmdBufferAllocInfo;
+
+ typedef struct {
+@@ -2043,29 +2076,29 @@ typedef struct {
+ } VkMemoryBarrier;
+
+
+-typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
+-typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
++typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance);
++typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+-typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
++typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+ typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
+ typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
+-typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
+-typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device);
+-typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+-typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+-typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties);
+-typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
++typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice);
++typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
++typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
++typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
++typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+ typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+ typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
+ typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
+ typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
+-typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
+-typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem);
++typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem);
++typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
+ typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
+ typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+@@ -2075,68 +2108,68 @@ typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffe
+ typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
+ typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+ typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+-typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+-typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+-typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+-typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+-typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
+-typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
+-typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence);
++typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
++typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
++typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo);
++typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo);
++typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseImageMemoryBindInfo* pBindInfo);
++typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence);
++typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
+ typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
+ typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
+-typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
+-typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore);
+-typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
+-typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event);
++typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore);
++typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent);
++typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
+ typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
+ typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
+-typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
+-typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool);
++typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool);
++typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+-typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
+-typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer);
+-typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
+-typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView);
+-typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
+-typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image);
++typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer);
++typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView);
++typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage);
++typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator);
+ typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+-typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
+-typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView);
+-typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
+-typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule);
+-typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
+-typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader);
+-typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
+-typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
++typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView);
++typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShaderModule);
++typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader);
++typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
++typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+ typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+-typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+-typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+-typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline);
+-typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
+-typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout);
+-typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
+-typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler);
+-typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
+-typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
+-typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
+-typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
++typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
++typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
++typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
++typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler);
++typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
++typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
++typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+ typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
+-typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
++typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
+ typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+-typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
+-typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer);
+-typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
+-typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass);
++typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
++typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass);
++typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator);
+ typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+-typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
+-typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool);
++typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool);
++typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
+ typedef VkResult (VKAPI *PFN_vkAllocCommandBuffers)(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
+-typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers);
++typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers);
+ typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
+ typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
+ typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
+@@ -2150,13 +2183,13 @@ typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDe
+ typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
+ typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
+ typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
+-typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
++typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+ typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+ typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+ typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+ typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+-typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
+-typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
++typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
++typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+ typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
+ typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
+ typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+@@ -2179,7 +2212,7 @@ typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool query
+ typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+ typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
+ typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+-typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
++typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values);
+ typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+ typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents);
+ typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer);
+@@ -2188,10 +2221,12 @@ typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t c
+ #ifdef VK_PROTOTYPES
+ VkResult VKAPI vkCreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkInstance* pInstance);
+
+ void VKAPI vkDestroyInstance(
+- VkInstance instance);
++ VkInstance instance,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkEnumeratePhysicalDevices(
+ VkInstance instance,
+@@ -2222,7 +2257,7 @@ void VKAPI vkGetPhysicalDeviceProperties(
+
+ void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice physicalDevice,
+- uint32_t* pCount,
++ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties);
+
+ void VKAPI vkGetPhysicalDeviceMemoryProperties(
+@@ -2240,29 +2275,31 @@ PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
+ VkResult VKAPI vkCreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkDevice* pDevice);
+
+ void VKAPI vkDestroyDevice(
+- VkDevice device);
++ VkDevice device,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkEnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+- uint32_t* pCount,
++ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+
+ VkResult VKAPI vkEnumerateDeviceExtensionProperties(
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+- uint32_t* pCount,
++ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+
+ VkResult VKAPI vkEnumerateInstanceLayerProperties(
+- uint32_t* pCount,
++ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+
+ VkResult VKAPI vkEnumerateDeviceLayerProperties(
+ VkPhysicalDevice physicalDevice,
+- uint32_t* pCount,
++ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+
+ void VKAPI vkGetDeviceQueue(
+@@ -2286,11 +2323,13 @@ VkResult VKAPI vkDeviceWaitIdle(
+ VkResult VKAPI vkAllocMemory(
+ VkDevice device,
+ const VkMemoryAllocInfo* pAllocInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkDeviceMemory* pMem);
+
+ void VKAPI vkFreeMemory(
+ VkDevice device,
+- VkDeviceMemory mem);
++ VkDeviceMemory mem,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkMapMemory(
+ VkDevice device,
+@@ -2344,7 +2383,7 @@ void VKAPI vkGetImageMemoryRequirements(
+ void VKAPI vkGetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+- uint32_t* pNumRequirements,
++ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+
+ void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+@@ -2354,35 +2393,37 @@ void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+ uint32_t samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+- uint32_t* pNumProperties,
++ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties);
+
+ VkResult VKAPI vkQueueBindSparseBufferMemory(
+ VkQueue queue,
+ VkBuffer buffer,
+- uint32_t numBindings,
++ uint32_t bindInfoCount,
+ const VkSparseMemoryBindInfo* pBindInfo);
+
+ VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(
+ VkQueue queue,
+ VkImage image,
+- uint32_t numBindings,
++ uint32_t bindInfoCount,
+ const VkSparseMemoryBindInfo* pBindInfo);
+
+ VkResult VKAPI vkQueueBindSparseImageMemory(
+ VkQueue queue,
+ VkImage image,
+- uint32_t numBindings,
++ uint32_t bindInfoCount,
+ const VkSparseImageMemoryBindInfo* pBindInfo);
+
+ VkResult VKAPI vkCreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkFence* pFence);
+
+ void VKAPI vkDestroyFence(
+ VkDevice device,
+- VkFence fence);
++ VkFence fence,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkResetFences(
+ VkDevice device,
+@@ -2403,20 +2444,24 @@ VkResult VKAPI vkWaitForFences(
+ VkResult VKAPI vkCreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkSemaphore* pSemaphore);
+
+ void VKAPI vkDestroySemaphore(
+ VkDevice device,
+- VkSemaphore semaphore);
++ VkSemaphore semaphore,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkEvent* pEvent);
+
+ void VKAPI vkDestroyEvent(
+ VkDevice device,
+- VkEvent event);
++ VkEvent event,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkGetEventStatus(
+ VkDevice device,
+@@ -2433,11 +2478,13 @@ VkResult VKAPI vkResetEvent(
+ VkResult VKAPI vkCreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkQueryPool* pQueryPool);
+
+ void VKAPI vkDestroyQueryPool(
+ VkDevice device,
+- VkQueryPool queryPool);
++ VkQueryPool queryPool,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkGetQueryPoolResults(
+ VkDevice device,
+@@ -2452,29 +2499,35 @@ VkResult VKAPI vkGetQueryPoolResults(
+ VkResult VKAPI vkCreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkBuffer* pBuffer);
+
+ void VKAPI vkDestroyBuffer(
+ VkDevice device,
+- VkBuffer buffer);
++ VkBuffer buffer,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkBufferView* pView);
+
+ void VKAPI vkDestroyBufferView(
+ VkDevice device,
+- VkBufferView bufferView);
++ VkBufferView bufferView,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkImage* pImage);
+
+ void VKAPI vkDestroyImage(
+ VkDevice device,
+- VkImage image);
++ VkImage image,
++ const VkAllocCallbacks* pAllocator);
+
+ void VKAPI vkGetImageSubresourceLayout(
+ VkDevice device,
+@@ -2485,38 +2538,46 @@ void VKAPI vkGetImageSubresourceLayout(
+ VkResult VKAPI vkCreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkImageView* pView);
+
+ void VKAPI vkDestroyImageView(
+ VkDevice device,
+- VkImageView imageView);
++ VkImageView imageView,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkShaderModule* pShaderModule);
+
+ void VKAPI vkDestroyShaderModule(
+ VkDevice device,
+- VkShaderModule shaderModule);
++ VkShaderModule shaderModule,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateShader(
+ VkDevice device,
+ const VkShaderCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkShader* pShader);
+
+ void VKAPI vkDestroyShader(
+ VkDevice device,
+- VkShader shader);
++ VkShader shader,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache);
+
+ void VKAPI vkDestroyPipelineCache(
+ VkDevice device,
+- VkPipelineCache pipelineCache);
++ VkPipelineCache pipelineCache,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkGetPipelineCacheData(
+ VkDevice device,
+@@ -2533,56 +2594,67 @@ VkResult VKAPI vkMergePipelineCaches(
+ VkResult VKAPI vkCreateGraphicsPipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+- uint32_t count,
++ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
++ const VkAllocCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+
+ VkResult VKAPI vkCreateComputePipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+- uint32_t count,
++ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
++ const VkAllocCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+
+ void VKAPI vkDestroyPipeline(
+ VkDevice device,
+- VkPipeline pipeline);
++ VkPipeline pipeline,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout);
+
+ void VKAPI vkDestroyPipelineLayout(
+ VkDevice device,
+- VkPipelineLayout pipelineLayout);
++ VkPipelineLayout pipelineLayout,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkSampler* pSampler);
+
+ void VKAPI vkDestroySampler(
+ VkDevice device,
+- VkSampler sampler);
++ VkSampler sampler,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout);
+
+ void VKAPI vkDestroyDescriptorSetLayout(
+ VkDevice device,
+- VkDescriptorSetLayout descriptorSetLayout);
++ VkDescriptorSetLayout descriptorSetLayout,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateDescriptorPool(
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool);
+
+ void VKAPI vkDestroyDescriptorPool(
+ VkDevice device,
+- VkDescriptorPool descriptorPool);
++ VkDescriptorPool descriptorPool,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkResetDescriptorPool(
+ VkDevice device,
+@@ -2597,7 +2669,7 @@ VkResult VKAPI vkAllocDescriptorSets(
+ VkResult VKAPI vkFreeDescriptorSets(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+- uint32_t count,
++ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets);
+
+ void VKAPI vkUpdateDescriptorSets(
+@@ -2610,20 +2682,24 @@ void VKAPI vkUpdateDescriptorSets(
+ VkResult VKAPI vkCreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer);
+
+ void VKAPI vkDestroyFramebuffer(
+ VkDevice device,
+- VkFramebuffer framebuffer);
++ VkFramebuffer framebuffer,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkRenderPass* pRenderPass);
+
+ void VKAPI vkDestroyRenderPass(
+ VkDevice device,
+- VkRenderPass renderPass);
++ VkRenderPass renderPass,
++ const VkAllocCallbacks* pAllocator);
+
+ void VKAPI vkGetRenderAreaGranularity(
+ VkDevice device,
+@@ -2633,11 +2709,13 @@ void VKAPI vkGetRenderAreaGranularity(
+ VkResult VKAPI vkCreateCommandPool(
+ VkDevice device,
+ const VkCmdPoolCreateInfo* pCreateInfo,
++ const VkAllocCallbacks* pAllocator,
+ VkCmdPool* pCmdPool);
+
+ void VKAPI vkDestroyCommandPool(
+ VkDevice device,
+- VkCmdPool cmdPool);
++ VkCmdPool cmdPool,
++ const VkAllocCallbacks* pAllocator);
+
+ VkResult VKAPI vkResetCommandPool(
+ VkDevice device,
+@@ -2652,7 +2730,7 @@ VkResult VKAPI vkAllocCommandBuffers(
+ void VKAPI vkFreeCommandBuffers(
+ VkDevice device,
+ VkCmdPool cmdPool,
+- uint32_t count,
++ uint32_t commandBufferCount,
+ const VkCmdBuffer* pCommandBuffers);
+
+ VkResult VKAPI vkBeginCommandBuffer(
+@@ -2720,7 +2798,7 @@ void VKAPI vkCmdBindDescriptorSets(
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+- uint32_t setCount,
++ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets);
+@@ -2757,14 +2835,14 @@ void VKAPI vkCmdDrawIndirect(
+ VkCmdBuffer cmdBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+- uint32_t count,
++ uint32_t drawCount,
+ uint32_t stride);
+
+ void VKAPI vkCmdDrawIndexedIndirect(
+ VkCmdBuffer cmdBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+- uint32_t count,
++ uint32_t drawCount,
+ uint32_t stride);
+
+ void VKAPI vkCmdDispatch(
+@@ -2930,8 +3008,8 @@ void VKAPI vkCmdPushConstants(
+ VkCmdBuffer cmdBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+- uint32_t start,
+- uint32_t length,
++ uint32_t offset,
++ uint32_t size,
+ const void* values);
+
+ void VKAPI vkCmdBeginRenderPass(
+@@ -3014,9 +3092,10 @@ typedef enum {
+ VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
+ VK_PRESENT_MODE_MAILBOX_KHR = 1,
+ VK_PRESENT_MODE_FIFO_KHR = 2,
++ VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
+ VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR,
+- VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_KHR,
+- VK_PRESENT_MODE_NUM = (VK_PRESENT_MODE_FIFO_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
++ VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
++ VK_PRESENT_MODE_NUM = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
+ VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkPresentModeKHR;
+
+@@ -3063,7 +3142,7 @@ typedef struct {
+ VkSurfaceTransformKHR preTransform;
+ uint32_t imageArraySize;
+ VkSharingMode sharingMode;
+- uint32_t queueFamilyCount;
++ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+ VkPresentModeKHR presentMode;
+ VkSwapchainKHR oldSwapchain;
+@@ -3074,17 +3153,17 @@ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t swapchainCount;
+- const VkSwapchainKHR* swapchains;
++ const VkSwapchainKHR* pSwapchains;
+ const uint32_t* imageIndices;
+ } VkPresentInfoKHR;
+
+
+ typedef VkResult (VKAPI *PFN_vkGetSurfacePropertiesKHR)(VkDevice device, VkSurfaceKHR surface, VkSurfacePropertiesKHR* pSurfaceProperties);
+-typedef VkResult (VKAPI *PFN_vkGetSurfaceFormatsKHR)(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats);
+-typedef VkResult (VKAPI *PFN_vkGetSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkPresentModeKHR* pPresentModes);
++typedef VkResult (VKAPI *PFN_vkGetSurfaceFormatsKHR)(VkDevice device, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
++typedef VkResult (VKAPI *PFN_vkGetSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
+ typedef VkResult (VKAPI *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain);
+ typedef void (VKAPI *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain);
+-typedef VkResult (VKAPI *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pCount, VkImage* pSwapchainImages);
++typedef VkResult (VKAPI *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
+ typedef VkResult (VKAPI *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
+ typedef VkResult (VKAPI *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo);
+
+@@ -3097,13 +3176,13 @@ VkResult VKAPI vkGetSurfacePropertiesKHR(
+ VkResult VKAPI vkGetSurfaceFormatsKHR(
+ VkDevice device,
+ VkSurfaceKHR surface,
+- uint32_t* pCount,
++ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats);
+
+ VkResult VKAPI vkGetSurfacePresentModesKHR(
+ VkDevice device,
+ VkSurfaceKHR surface,
+- uint32_t* pCount,
++ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes);
+
+ VkResult VKAPI vkCreateSwapchainKHR(
+@@ -3118,7 +3197,7 @@ void VKAPI vkDestroySwapchainKHR(
+ VkResult VKAPI vkGetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+- uint32_t* pCount,
++ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages);
+
+ VkResult VKAPI vkAcquireNextImageKHR(
+@@ -3154,7 +3233,7 @@ typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
+
+ typedef struct {
+ VkDisplayKHR display;
+- const char* displayName;
++ const char* displayName;
+ VkExtent2D physicalDimensions;
+ VkExtent2D physicalResolution;
+ VkSurfaceTransformFlagsKHR supportedTransforms;
+@@ -3213,22 +3292,22 @@ typedef struct {
+ } VkSurfaceDescriptionDisplayPlaneKHR;
+
+
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkDisplayPropertiesKHR* pProperties);
+-typedef VkResult (VKAPI *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pCount, VkDisplayModePropertiesKHR* pModeProperties);
++typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
++typedef VkResult (VKAPI *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
+ typedef VkResult (VKAPI *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, VkDisplayModeKHR* pMode);
+ typedef VkResult (VKAPI *PFN_vkGetDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlanePropertiesKHR* pProperties);
+
+ #ifdef VK_PROTOTYPES
+ VkResult VKAPI vkGetPhysicalDeviceDisplayPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+- uint32_t* pCount,
++ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties);
+
+ VkResult VKAPI vkGetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+- uint32_t* pCount,
+- VkDisplayModePropertiesKHR* pModeProperties);
++ uint32_t* pPropertyCount,
++ VkDisplayModePropertiesKHR* pProperties);
+
+ VkResult VKAPI vkCreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 255ad97..7622e4d 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -42,13 +42,13 @@ namespace {
+ } // namespace
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) {
+- return vulkan::CreateInstance(pCreateInfo, pInstance);
++VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance) {
++ return vulkan::CreateInstance(pCreateInfo, pAllocator, pInstance);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyInstance(VkInstance instance) {
+- GetVtbl(instance).DestroyInstance(instance);
++void vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(instance).DestroyInstance(instance, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -72,8 +72,8 @@ void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDe
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
+- GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
++void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
++ GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+ }
+
+ __attribute__((visibility("default")))
+@@ -97,33 +97,33 @@ void vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, V
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) {
+- return GetVtbl(physicalDevice).CreateDevice(physicalDevice, pCreateInfo, pDevice);
++VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice) {
++ return GetVtbl(physicalDevice).CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyDevice(VkDevice device) {
+- vulkan::DestroyDevice(device);
++void vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator) {
++ vulkan::DestroyDevice(device, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkEnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
+- return vulkan::EnumerateInstanceLayerProperties(pCount, pProperties);
++VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
++ return vulkan::EnumerateInstanceLayerProperties(pPropertyCount, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) {
+- return vulkan::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
++VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
++ return vulkan::EnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties) {
+- return GetVtbl(physicalDevice).EnumerateDeviceLayerProperties(physicalDevice, pCount, pProperties);
++VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
++ return GetVtbl(physicalDevice).EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) {
+- return GetVtbl(physicalDevice).EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties);
++VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
++ return GetVtbl(physicalDevice).EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+@@ -147,13 +147,13 @@ VkResult vkDeviceWaitIdle(VkDevice device) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) {
+- return GetVtbl(device).AllocMemory(device, pAllocInfo, pMem);
++VkResult vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem) {
++ return GetVtbl(device).AllocMemory(device, pAllocInfo, pAllocator, pMem);
+ }
+
+ __attribute__((visibility("default")))
+-void vkFreeMemory(VkDevice device, VkDeviceMemory mem) {
+- GetVtbl(device).FreeMemory(device, mem);
++void vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).FreeMemory(device, mem, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -202,38 +202,38 @@ VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, V
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+- GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
++void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
++ GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
+- GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
++void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
++ GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
+- return GetVtbl(queue).QueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
++VkResult vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo) {
++ return GetVtbl(queue).QueueBindSparseBufferMemory(queue, buffer, bindInfoCount, pBindInfo);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
+- return GetVtbl(queue).QueueBindSparseImageOpaqueMemory(queue, image, numBindings, pBindInfo);
++VkResult vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo) {
++ return GetVtbl(queue).QueueBindSparseImageOpaqueMemory(queue, image, bindInfoCount, pBindInfo);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo) {
+- return GetVtbl(queue).QueueBindSparseImageMemory(queue, image, numBindings, pBindInfo);
++VkResult vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseImageMemoryBindInfo* pBindInfo) {
++ return GetVtbl(queue).QueueBindSparseImageMemory(queue, image, bindInfoCount, pBindInfo);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) {
+- return GetVtbl(device).CreateFence(device, pCreateInfo, pFence);
++VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence) {
++ return GetVtbl(device).CreateFence(device, pCreateInfo, pAllocator, pFence);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyFence(VkDevice device, VkFence fence) {
+- GetVtbl(device).DestroyFence(device, fence);
++void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyFence(device, fence, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -252,23 +252,23 @@ VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pF
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) {
+- return GetVtbl(device).CreateSemaphore(device, pCreateInfo, pSemaphore);
++VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore) {
++ return GetVtbl(device).CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore) {
+- GetVtbl(device).DestroySemaphore(device, semaphore);
++void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroySemaphore(device, semaphore, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) {
+- return GetVtbl(device).CreateEvent(device, pCreateInfo, pEvent);
++VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent) {
++ return GetVtbl(device).CreateEvent(device, pCreateInfo, pAllocator, pEvent);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyEvent(VkDevice device, VkEvent event) {
+- GetVtbl(device).DestroyEvent(device, event);
++void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyEvent(device, event, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -287,13 +287,13 @@ VkResult vkResetEvent(VkDevice device, VkEvent event) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) {
+- return GetVtbl(device).CreateQueryPool(device, pCreateInfo, pQueryPool);
++VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool) {
++ return GetVtbl(device).CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool) {
+- GetVtbl(device).DestroyQueryPool(device, queryPool);
++void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyQueryPool(device, queryPool, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -302,33 +302,33 @@ VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) {
+- return GetVtbl(device).CreateBuffer(device, pCreateInfo, pBuffer);
++VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer) {
++ return GetVtbl(device).CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyBuffer(VkDevice device, VkBuffer buffer) {
+- GetVtbl(device).DestroyBuffer(device, buffer);
++void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyBuffer(device, buffer, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) {
+- return GetVtbl(device).CreateBufferView(device, pCreateInfo, pView);
++VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView) {
++ return GetVtbl(device).CreateBufferView(device, pCreateInfo, pAllocator, pView);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyBufferView(VkDevice device, VkBufferView bufferView) {
+- GetVtbl(device).DestroyBufferView(device, bufferView);
++void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyBufferView(device, bufferView, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) {
+- return GetVtbl(device).CreateImage(device, pCreateInfo, pImage);
++VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage) {
++ return GetVtbl(device).CreateImage(device, pCreateInfo, pAllocator, pImage);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyImage(VkDevice device, VkImage image) {
+- GetVtbl(device).DestroyImage(device, image);
++void vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyImage(device, image, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -337,43 +337,43 @@ void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSu
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) {
+- return GetVtbl(device).CreateImageView(device, pCreateInfo, pView);
++VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView) {
++ return GetVtbl(device).CreateImageView(device, pCreateInfo, pAllocator, pView);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyImageView(VkDevice device, VkImageView imageView) {
+- GetVtbl(device).DestroyImageView(device, imageView);
++void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyImageView(device, imageView, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) {
+- return GetVtbl(device).CreateShaderModule(device, pCreateInfo, pShaderModule);
++VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShaderModule) {
++ return GetVtbl(device).CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule) {
+- GetVtbl(device).DestroyShaderModule(device, shaderModule);
++void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyShaderModule(device, shaderModule, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) {
+- return GetVtbl(device).CreateShader(device, pCreateInfo, pShader);
++VkResult vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader) {
++ return GetVtbl(device).CreateShader(device, pCreateInfo, pAllocator, pShader);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyShader(VkDevice device, VkShader shader) {
+- GetVtbl(device).DestroyShader(device, shader);
++void vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyShader(device, shader, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) {
+- return GetVtbl(device).CreatePipelineCache(device, pCreateInfo, pPipelineCache);
++VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
++ return GetVtbl(device).CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache) {
+- GetVtbl(device).DestroyPipelineCache(device, pipelineCache);
++void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyPipelineCache(device, pipelineCache, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -387,58 +387,58 @@ VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint3
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) {
+- return GetVtbl(device).CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
++VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) {
++ return GetVtbl(device).CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) {
+- return GetVtbl(device).CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
++VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) {
++ return GetVtbl(device).CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyPipeline(VkDevice device, VkPipeline pipeline) {
+- GetVtbl(device).DestroyPipeline(device, pipeline);
++void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyPipeline(device, pipeline, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) {
+- return GetVtbl(device).CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
++VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
++ return GetVtbl(device).CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout) {
+- GetVtbl(device).DestroyPipelineLayout(device, pipelineLayout);
++void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyPipelineLayout(device, pipelineLayout, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) {
+- return GetVtbl(device).CreateSampler(device, pCreateInfo, pSampler);
++VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler) {
++ return GetVtbl(device).CreateSampler(device, pCreateInfo, pAllocator, pSampler);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroySampler(VkDevice device, VkSampler sampler) {
+- GetVtbl(device).DestroySampler(device, sampler);
++void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroySampler(device, sampler, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) {
+- return GetVtbl(device).CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
++VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
++ return GetVtbl(device).CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout) {
+- GetVtbl(device).DestroyDescriptorSetLayout(device, descriptorSetLayout);
++void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) {
+- return GetVtbl(device).CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
++VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
++ return GetVtbl(device).CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {
+- GetVtbl(device).DestroyDescriptorPool(device, descriptorPool);
++void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyDescriptorPool(device, descriptorPool, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -452,8 +452,8 @@ VkResult vkAllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo*
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) {
+- return GetVtbl(device).FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
++VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
++ return GetVtbl(device).FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+ }
+
+ __attribute__((visibility("default")))
+@@ -462,23 +462,23 @@ void vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteD
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) {
+- return GetVtbl(device).CreateFramebuffer(device, pCreateInfo, pFramebuffer);
++VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
++ return GetVtbl(device).CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer) {
+- GetVtbl(device).DestroyFramebuffer(device, framebuffer);
++void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyFramebuffer(device, framebuffer, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) {
+- return GetVtbl(device).CreateRenderPass(device, pCreateInfo, pRenderPass);
++VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass) {
++ return GetVtbl(device).CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass) {
+- GetVtbl(device).DestroyRenderPass(device, renderPass);
++void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyRenderPass(device, renderPass, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -487,13 +487,13 @@ void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExte
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) {
+- return GetVtbl(device).CreateCommandPool(device, pCreateInfo, pCmdPool);
++VkResult vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool) {
++ return GetVtbl(device).CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool) {
+- GetVtbl(device).DestroyCommandPool(device, cmdPool);
++void vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator) {
++ GetVtbl(device).DestroyCommandPool(device, cmdPool, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -507,8 +507,8 @@ VkResult vkAllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pAll
+ }
+
+ __attribute__((visibility("default")))
+-void vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers) {
+- GetVtbl(device).FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
++void vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers) {
++ GetVtbl(device).FreeCommandBuffers(device, cmdPool, commandBufferCount, pCommandBuffers);
+ }
+
+ __attribute__((visibility("default")))
+@@ -577,8 +577,8 @@ void vkCmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+- GetVtbl(cmdBuffer).CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
++void vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
++ GetVtbl(cmdBuffer).CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+ }
+
+ __attribute__((visibility("default")))
+@@ -602,13 +602,13 @@ void vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t insta
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
+- GetVtbl(cmdBuffer).CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
++void vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
++ GetVtbl(cmdBuffer).CmdDrawIndirect(cmdBuffer, buffer, offset, drawCount, stride);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
+- GetVtbl(cmdBuffer).CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
++void vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
++ GetVtbl(cmdBuffer).CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, drawCount, stride);
+ }
+
+ __attribute__((visibility("default")))
+@@ -722,8 +722,8 @@ void vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uin
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
+- GetVtbl(cmdBuffer).CmdPushConstants(cmdBuffer, layout, stageFlags, start, length, values);
++void vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) {
++ GetVtbl(cmdBuffer).CmdPushConstants(cmdBuffer, layout, stageFlags, offset, size, values);
+ }
+
+ __attribute__((visibility("default")))
+@@ -762,13 +762,13 @@ VkResult vkGetSurfacePropertiesKHR(VkDevice device, VkSurfaceKHR surface, VkSurf
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetSurfaceFormatsKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats) {
+- return GetVtbl(device).GetSurfaceFormatsKHR(device, surface, pCount, pSurfaceFormats);
++VkResult vkGetSurfaceFormatsKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
++ return GetVtbl(device).GetSurfaceFormatsKHR(device, surface, pSurfaceFormatCount, pSurfaceFormats);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkPresentModeKHR* pPresentModes) {
+- return GetVtbl(device).GetSurfacePresentModesKHR(device, surface, pCount, pPresentModes);
++VkResult vkGetSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
++ return GetVtbl(device).GetSurfacePresentModesKHR(device, surface, pPresentModeCount, pPresentModes);
+ }
+
+ __attribute__((visibility("default")))
+@@ -782,8 +782,8 @@ void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pCount, VkImage* pSwapchainImages) {
+- return GetVtbl(device).GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages);
++VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
++ return GetVtbl(device).GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
+index a44026f..d5795d7 100644
+--- a/vulkan/libvulkan/loader.cpp
++++ b/vulkan/libvulkan/loader.cpp
+@@ -22,8 +22,8 @@
+ #include <dirent.h>
+ #include <dlfcn.h>
+ #include <inttypes.h>
+-#include <malloc.h>
+ #include <pthread.h>
++#include <stdlib.h>
+ #include <string.h>
+ // standard C++ headers
+ #include <algorithm>
+@@ -58,7 +58,13 @@ typedef struct VkLayerLinkedListElem_ {
+ // Define Handle typedef to be void* as returned from dlopen.
+ typedef void* SharedLibraryHandle;
+
+-// Custom versions of std classes that use the vulkan alloc callback.
++// Standard-library allocator that delegates to VkAllocCallbacks.
++//
++// TODO(jessehall): This class currently always uses
++// VK_SYSTEM_ALLOC_SCOPE_INSTANCE. The scope to use could be a template
++// parameter or a constructor parameter. The former would help catch bugs
++// where we use the wrong scope, e.g. adding a command-scope string to an
++// instance-scope vector. But that might also be pretty annoying to deal with.
+ template <class T>
+ class CallbackAllocator {
+ public:
+@@ -73,7 +79,7 @@ class CallbackAllocator {
+
+ T* allocate(std::size_t n) {
+ void* mem = alloc->pfnAlloc(alloc->pUserData, n * sizeof(T), alignof(T),
+- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
++ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+ return static_cast<T*>(mem);
+ }
+
+@@ -208,8 +214,39 @@ inline const DeviceVtbl* GetVtbl(VkQueue queue) {
+ return *reinterpret_cast<DeviceVtbl**>(queue);
+ }
+
+-void* DefaultAlloc(void*, size_t size, size_t alignment, VkSystemAllocType) {
+- return memalign(alignment, size);
++void* DefaultAlloc(void*, size_t size, size_t alignment, VkSystemAllocScope) {
++ void* ptr = nullptr;
++ return posix_memalign(&ptr, alignment, size) == 0 ? ptr : nullptr;
++}
++
++void* DefaultRealloc(void*,
++ void* ptr,
++ size_t size,
++ size_t alignment,
++ VkSystemAllocScope) {
++ if (size == 0) {
++ free(ptr);
++ return nullptr;
++ }
++
++ // TODO(jessehall): Right now we never shrink allocations; if the new
++ // request is smaller than the existing chunk, we just continue using it.
++ // Right now the loader never reallocs, so this doesn't matter. If that
++ // changes, or if this code is copied into some other project, this should
++ // probably have a heuristic to allocate-copy-free when doing so will save
++ // "enough" space.
++ size_t old_size = ptr ? malloc_usable_size(ptr) : 0;
++ if (size <= old_size)
++ return ptr;
++
++ void* new_ptr = nullptr;
++ if (posix_memalign(&new_ptr, alignment, size) != 0)
++ return nullptr;
++ if (ptr) {
++ memcpy(new_ptr, ptr, std::min(old_size, size));
++ free(ptr);
++ }
++ return new_ptr;
+ }
+
+ void DefaultFree(void*, void* pMem) {
+@@ -219,6 +256,7 @@ void DefaultFree(void*, void* pMem) {
+ const VkAllocCallbacks kDefaultAllocCallbacks = {
+ .pUserData = nullptr,
+ .pfnAlloc = DefaultAlloc,
++ .pfnRealloc = DefaultRealloc,
+ .pfnFree = DefaultFree,
+ };
+
+@@ -418,7 +456,7 @@ VkResult ActivateAllLayers(TInfo create_info, Instance* instance, TObject* objec
+ }
+ }
+ // Load app layers
+- for (uint32_t i = 0; i < create_info->layerCount; ++i) {
++ for (uint32_t i = 0; i < create_info->enabledLayerNameCount; ++i) {
+ String layer_name(create_info->ppEnabledLayerNames[i],
+ string_allocator);
+ auto element = instance->layers.find(layer_name);
+@@ -439,17 +477,18 @@ template <class TCreateInfo>
+ bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
+ const char* extension_name,
+ const VkAllocCallbacks* alloc) {
+- for (uint32_t i = 0; i < local_create_info.extensionCount; ++i) {
++ for (uint32_t i = 0; i < local_create_info.enabledExtensionNameCount; ++i) {
+ if (!strcmp(extension_name,
+ local_create_info.ppEnabledExtensionNames[i])) {
+ return false;
+ }
+ }
+- uint32_t extension_count = local_create_info.extensionCount;
+- local_create_info.extensionCount++;
++ uint32_t extension_count = local_create_info.enabledExtensionNameCount;
++ local_create_info.enabledExtensionNameCount++;
+ void* mem = alloc->pfnAlloc(
+- alloc->pUserData, local_create_info.extensionCount * sizeof(char*),
+- alignof(char*), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
++ alloc->pUserData,
++ local_create_info.enabledExtensionNameCount * sizeof(char*),
++ alignof(char*), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+ if (mem) {
+ const char** enabled_extensions = static_cast<const char**>(mem);
+ for (uint32_t i = 0; i < extension_count; ++i) {
+@@ -461,7 +500,7 @@ bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
+ } else {
+ ALOGW("%s extension cannot be enabled: memory allocation failed",
+ extension_name);
+- local_create_info.extensionCount--;
++ local_create_info.enabledExtensionNameCount--;
+ return false;
+ }
+ return true;
+@@ -537,12 +576,14 @@ PFN_vkVoidFunction GetLayerDeviceProcAddr(VkDevice device, const char* name) {
+ // "Bottom" functions. These are called at the end of the instance dispatch
+ // chain.
+
+-void DestroyInstanceBottom(VkInstance instance) {
++void DestroyInstanceBottom(VkInstance instance,
++ const VkAllocCallbacks* allocator) {
+ // These checks allow us to call DestroyInstanceBottom from any error path
+ // in CreateInstanceBottom, before the driver instance is fully initialized.
+ if (instance->drv.vtbl.instance != VK_NULL_HANDLE &&
+ instance->drv.vtbl.DestroyInstance) {
+- instance->drv.vtbl.DestroyInstance(instance->drv.vtbl.instance);
++ instance->drv.vtbl.DestroyInstance(instance->drv.vtbl.instance,
++ allocator);
+ }
+ if (instance->message) {
+ PFN_vkDbgDestroyMsgCallback DebugDestroyMessageCallback;
+@@ -561,21 +602,22 @@ void DestroyInstanceBottom(VkInstance instance) {
+ }
+
+ VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
++ const VkAllocCallbacks* allocator,
+ VkInstance* instance_ptr) {
+ Instance* instance = *instance_ptr;
+ VkResult result;
+
+- result =
+- g_hwdevice->CreateInstance(create_info, &instance->drv.vtbl.instance);
++ result = g_hwdevice->CreateInstance(create_info, instance->alloc,
++ &instance->drv.vtbl.instance);
+ if (result != VK_SUCCESS) {
+- DestroyInstanceBottom(instance);
++ DestroyInstanceBottom(instance, allocator);
+ return result;
+ }
+
+ if (!LoadInstanceVtbl(
+ instance->drv.vtbl.instance, instance->drv.vtbl.instance,
+ g_hwdevice->GetInstanceProcAddr, instance->drv.vtbl)) {
+- DestroyInstanceBottom(instance);
++ DestroyInstanceBottom(instance, allocator);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+@@ -587,7 +629,7 @@ VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
+ "vkGetDeviceProcAddr"));
+ if (!instance->drv.GetDeviceProcAddr) {
+ ALOGE("missing instance proc: \"%s\"", "vkGetDeviceProcAddr");
+- DestroyInstanceBottom(instance);
++ DestroyInstanceBottom(instance, allocator);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+@@ -600,7 +642,7 @@ VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
+ } else {
+ ALOGE("invalid VkInstance dispatch magic: 0x%" PRIxPTR,
+ dispatch->magic);
+- DestroyInstanceBottom(instance);
++ DestroyInstanceBottom(instance, allocator);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+@@ -608,7 +650,7 @@ VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
+ result = instance->drv.vtbl.EnumeratePhysicalDevices(
+ instance->drv.vtbl.instance, &num_physical_devices, nullptr);
+ if (result != VK_SUCCESS) {
+- DestroyInstanceBottom(instance);
++ DestroyInstanceBottom(instance, allocator);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+ num_physical_devices = std::min(num_physical_devices, kMaxPhysicalDevices);
+@@ -616,7 +658,7 @@ VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
+ instance->drv.vtbl.instance, &num_physical_devices,
+ instance->physical_devices);
+ if (result != VK_SUCCESS) {
+- DestroyInstanceBottom(instance);
++ DestroyInstanceBottom(instance, allocator);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+ for (uint32_t i = 0; i < num_physical_devices; i++) {
+@@ -625,7 +667,7 @@ VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
+ if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
+ ALOGE("invalid VkPhysicalDevice dispatch magic: 0x%" PRIxPTR,
+ dispatch->magic);
+- DestroyInstanceBottom(instance);
++ DestroyInstanceBottom(instance, allocator);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+ dispatch->vtbl = instance->vtbl;
+@@ -696,13 +738,21 @@ void GetPhysicalDeviceMemoryPropertiesBottom(
+
+ VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
+ const VkDeviceCreateInfo* create_info,
++ const VkAllocCallbacks* allocator,
+ VkDevice* out_device) {
+ Instance& instance = *static_cast<Instance*>(GetVtbl(pdev)->instance);
+ VkResult result;
+
+- void* mem = instance.alloc->pfnAlloc(instance.alloc->pUserData,
+- sizeof(Device), alignof(Device),
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
++ if (!allocator) {
++ if (instance.alloc)
++ allocator = instance.alloc;
++ else
++ allocator = &kDefaultAllocCallbacks;
++ }
++
++ void* mem =
++ allocator->pfnAlloc(allocator->pUserData, sizeof(Device),
++ alignof(Device), VK_SYSTEM_ALLOC_SCOPE_DEVICE);
+ if (!mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ Device* device = new (mem) Device(&instance);
+@@ -714,7 +764,8 @@ VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
+ }
+
+ VkDevice drv_device;
+- result = instance.drv.vtbl.CreateDevice(pdev, create_info, &drv_device);
++ result = instance.drv.vtbl.CreateDevice(pdev, create_info, allocator,
++ &drv_device);
+ if (result != VK_SUCCESS) {
+ DestroyDevice(device);
+ return result;
+@@ -727,7 +778,7 @@ VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
+ PFN_vkDestroyDevice destroy_device =
+ reinterpret_cast<PFN_vkDestroyDevice>(
+ instance.drv.GetDeviceProcAddr(drv_device, "vkDestroyDevice"));
+- destroy_device(drv_device);
++ destroy_device(drv_device, allocator);
+ DestroyDevice(device);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+@@ -778,7 +829,7 @@ VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
+ reinterpret_cast<PFN_vkCreateDevice>(
+ device->vtbl_storage.GetDeviceProcAddr(drv_device,
+ "vkCreateDevice"));
+- layer_createDevice(pdev, create_info, &drv_device);
++ layer_createDevice(pdev, create_info, allocator, &drv_device);
+
+ // TODO(mlentine) : This is needed to use WSI layer validation. Remove this
+ // when new version of layer initialization exits.
+@@ -896,23 +947,25 @@ VkResult EnumerateInstanceLayerProperties(uint32_t* count,
+ }
+
+ VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
++ const VkAllocCallbacks* allocator,
+ VkInstance* out_instance) {
+ VkResult result;
+
+ if (!EnsureInitialized())
+ return VK_ERROR_INITIALIZATION_FAILED;
+
++ if (!allocator)
++ allocator = &kDefaultAllocCallbacks;
++
+ VkInstanceCreateInfo local_create_info = *create_info;
+- if (!local_create_info.pAllocCb)
+- local_create_info.pAllocCb = &kDefaultAllocCallbacks;
+ create_info = &local_create_info;
+
+- void* instance_mem = create_info->pAllocCb->pfnAlloc(
+- create_info->pAllocCb->pUserData, sizeof(Instance), alignof(Instance),
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
++ void* instance_mem =
++ allocator->pfnAlloc(allocator->pUserData, sizeof(Instance),
++ alignof(Instance), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+ if (!instance_mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+- Instance* instance = new (instance_mem) Instance(create_info->pAllocCb);
++ Instance* instance = new (instance_mem) Instance(allocator);
+
+ instance->vtbl_storage = kBottomInstanceFunctions;
+ instance->vtbl_storage.instance = instance;
+@@ -930,7 +983,7 @@ VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+
+ result = ActivateAllLayers(create_info, instance, instance);
+ if (result != VK_SUCCESS) {
+- DestroyInstanceBottom(instance);
++ DestroyInstanceBottom(instance, allocator);
+ return result;
+ }
+
+@@ -973,7 +1026,7 @@ VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+ if (!LoadInstanceVtbl(static_cast<VkInstance>(base_object),
+ static_cast<VkInstance>(next_object),
+ next_get_proc_addr, instance->vtbl_storage)) {
+- DestroyInstanceBottom(instance);
++ DestroyInstanceBottom(instance, allocator);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+@@ -988,7 +1041,8 @@ VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+ }
+
+ *out_instance = instance;
+- result = instance->vtbl_storage.CreateInstance(create_info, out_instance);
++ result = instance->vtbl_storage.CreateInstance(create_info, allocator,
++ out_instance);
+ if (enable_callback)
+ FreeAllocatedCreateInfo(local_create_info, instance->alloc);
+ if (result <= 0) {
+@@ -1079,7 +1133,7 @@ VkResult AllocCommandBuffers(VkDevice device,
+ VkResult result = vtbl->AllocCommandBuffers(device, alloc_info, cmdbuffers);
+ if (result != VK_SUCCESS)
+ return result;
+- for (uint32_t i = 0; i < alloc_info->count; i++) {
++ for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
+ hwvulkan_dispatch_t* dispatch =
+ reinterpret_cast<hwvulkan_dispatch_t*>(cmdbuffers[i]);
+ ALOGE_IF(dispatch->magic != HWVULKAN_DISPATCH_MAGIC,
+@@ -1090,14 +1144,15 @@ VkResult AllocCommandBuffers(VkDevice device,
+ return VK_SUCCESS;
+ }
+
+-VkResult DestroyDevice(VkDevice drv_device) {
++VkResult DestroyDevice(VkDevice drv_device,
++ const VkAllocCallbacks* /*allocator*/) {
+ const DeviceVtbl* vtbl = GetVtbl(drv_device);
+ Device* device = static_cast<Device*>(vtbl->device);
+ for (auto it = device->active_layers.begin();
+ it != device->active_layers.end(); ++it) {
+ DeactivateLayer(device->instance, it);
+ }
+- vtbl->DestroyDevice(drv_device);
++ vtbl->DestroyDevice(drv_device, device->instance->alloc);
+ DestroyDevice(device);
+ return VK_SUCCESS;
+ }
+@@ -1105,9 +1160,9 @@ VkResult DestroyDevice(VkDevice drv_device) {
+ void* AllocMem(VkInstance instance,
+ size_t size,
+ size_t align,
+- VkSystemAllocType type) {
++ VkSystemAllocScope scope) {
+ const VkAllocCallbacks* alloc_cb = instance->alloc;
+- return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, type);
++ return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, scope);
+ }
+
+ void FreeMem(VkInstance instance, void* ptr) {
+@@ -1118,10 +1173,10 @@ void FreeMem(VkInstance instance, void* ptr) {
+ void* AllocMem(VkDevice device,
+ size_t size,
+ size_t align,
+- VkSystemAllocType type) {
++ VkSystemAllocScope scope) {
+ const VkAllocCallbacks* alloc_cb =
+ static_cast<Device*>(GetVtbl(device)->device)->instance->alloc;
+- return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, type);
++ return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, scope);
+ }
+
+ void FreeMem(VkDevice device, void* ptr) {
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index 15e2779..e166887 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -216,6 +216,7 @@ VkResult EnumerateInstanceExtensionProperties(
+ VkResult EnumerateInstanceLayerProperties(uint32_t* count,
+ VkLayerProperties* properties);
+ VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
++ const VkAllocCallbacks* pAllocator,
+ VkInstance* instance);
+ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name);
+ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice drv_device, const char* name);
+@@ -226,17 +227,17 @@ void GetDeviceQueue(VkDevice drv_device,
+ VkResult AllocCommandBuffers(VkDevice device,
+ const VkCmdBufferAllocInfo* alloc_info,
+ VkCmdBuffer* cmdbuffers);
+-VkResult DestroyDevice(VkDevice drv_device);
++VkResult DestroyDevice(VkDevice drv_device, const VkAllocCallbacks* pAllocator);
+
+ void* AllocMem(VkInstance instance,
+ size_t size,
+ size_t align,
+- VkSystemAllocType type);
++ VkSystemAllocScope scope);
+ void FreeMem(VkInstance instance, void* ptr);
+ void* AllocMem(VkDevice device,
+ size_t size,
+ size_t align,
+- VkSystemAllocType type);
++ VkSystemAllocScope scope);
+ void FreeMem(VkDevice device, void* ptr);
+ const DeviceVtbl& GetDriverVtbl(VkDevice device);
+ const DeviceVtbl& GetDriverVtbl(VkQueue queue);
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index 2922465..f6ab081 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -49,6 +49,19 @@ struct NativeBaseDeleter {
+ void operator()(T* obj) { obj->common.decRef(&obj->common); }
+ };
+
++template <typename Host>
++struct AllocScope {};
++
++template <>
++struct AllocScope<VkInstance> {
++ static const VkSystemAllocScope kScope = VK_SYSTEM_ALLOC_SCOPE_INSTANCE;
++};
++
++template <>
++struct AllocScope<VkDevice> {
++ static const VkSystemAllocScope kScope = VK_SYSTEM_ALLOC_SCOPE_DEVICE;
++};
++
+ template <typename T, typename Host>
+ class VulkanAllocator {
+ public:
+@@ -62,7 +75,7 @@ class VulkanAllocator {
+
+ T* allocate(size_t n) const {
+ return static_cast<T*>(AllocMem(host_, n * sizeof(T), alignof(T),
+- VK_SYSTEM_ALLOC_TYPE_INTERNAL));
++ AllocScope<Host>::kScope));
+ }
+ void deallocate(T* p, size_t) const { return FreeMem(host_, p); }
+
+@@ -129,7 +142,7 @@ VkResult CreateAndroidSurfaceKHR(VkInstance instance,
+ ANativeWindow* window,
+ VkSurfaceKHR* out_surface) {
+ void* mem = AllocMem(instance, sizeof(Surface), alignof(Surface),
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
++ VK_SYSTEM_ALLOC_SCOPE_OBJECT);
+ if (!mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ Surface* surface = new (mem) Surface;
+@@ -362,7 +375,7 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ // After this point, we must deallocate the swapchain on error.
+
+ void* mem = AllocMem(device, sizeof(Swapchain), alignof(Swapchain),
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
++ VK_SYSTEM_ALLOC_SCOPE_OBJECT);
+ if (!mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ Swapchain* swapchain = new (mem) Swapchain(surface, num_images);
+@@ -391,7 +404,7 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ .usage = create_info->imageUsageFlags,
+ .flags = 0,
+ .sharingMode = create_info->sharingMode,
+- .queueFamilyCount = create_info->queueFamilyCount,
++ .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
+ .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
+ };
+
+@@ -418,7 +431,8 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ image_native_buffer.format = img.buffer->format;
+ image_native_buffer.usage = img.buffer->usage;
+
+- result = driver_vtbl.CreateImage(device, &image_create, &img.image);
++ result =
++ driver_vtbl.CreateImage(device, &image_create, nullptr, &img.image);
+ if (result != VK_SUCCESS) {
+ ALOGD("vkCreateImage w/ native buffer failed: %u", result);
+ break;
+@@ -441,7 +455,7 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ }
+ if (result != VK_SUCCESS) {
+ if (img.image)
+- driver_vtbl.DestroyImage(device, img.image);
++ driver_vtbl.DestroyImage(device, img.image, nullptr);
+ }
+ }
+
+@@ -469,7 +483,7 @@ VkResult DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain_handle) {
+ img.dequeued = false;
+ }
+ if (img.image) {
+- driver_vtbl.DestroyImage(device, img.image);
++ driver_vtbl.DestroyImage(device, img.image, nullptr);
+ }
+ }
+
+@@ -592,7 +606,7 @@ VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info) {
+ VkResult final_result = VK_SUCCESS;
+ for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
+ Swapchain& swapchain =
+- *SwapchainFromHandle(present_info->swapchains[sc]);
++ *SwapchainFromHandle(present_info->pSwapchains[sc]);
+ ANativeWindow* window = swapchain.surface.window.get();
+ uint32_t image_idx = present_info->imageIndices[sc];
+ Swapchain::Image& img = swapchain.images[image_idx];
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 0f8382f..fe6a1e8 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -35,7 +35,7 @@ struct VkPhysicalDevice_T {
+
+ struct VkInstance_T {
+ hwvulkan_dispatch_t dispatch;
+- const VkAllocCallbacks* alloc;
++ VkAllocCallbacks allocator;
+ VkPhysicalDevice_T physical_device;
+ };
+
+@@ -67,7 +67,6 @@ namespace {
+ namespace HandleType {
+ enum Enum {
+ kBufferView,
+- kCmdPool,
+ kDescriptorPool,
+ kDescriptorSet,
+ kDescriptorSetLayout,
+@@ -96,6 +95,7 @@ const VkDeviceSize kMaxDeviceMemory = VkDeviceSize(INTPTR_MAX) + 1;
+
+ struct VkDevice_T {
+ hwvulkan_dispatch_t dispatch;
++ VkAllocCallbacks allocator;
+ VkInstance_T* instance;
+ VkQueue_T queue;
+ std::array<uint64_t, HandleType::kNumTypes> next_handle;
+@@ -130,22 +130,22 @@ __attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = {
+
+ namespace {
+
+-VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
++VkResult CreateInstance(const VkInstanceCreateInfo* /*create_info*/,
++ const VkAllocCallbacks* allocator,
+ VkInstance* out_instance) {
+ // Assume the loader provided alloc callbacks even if the app didn't.
+ ALOG_ASSERT(
+- create_info->pAllocCb,
++ allocator,
+ "Missing alloc callbacks, loader or app should have provided them");
+
+- VkInstance_T* instance =
+- static_cast<VkInstance_T*>(create_info->pAllocCb->pfnAlloc(
+- create_info->pAllocCb->pUserData, sizeof(VkInstance_T),
+- alignof(VkInstance_T), VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
++ VkInstance_T* instance = static_cast<VkInstance_T*>(allocator->pfnAlloc(
++ allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
++ VK_SYSTEM_ALLOC_SCOPE_INSTANCE));
+ if (!instance)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ instance->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
+- instance->alloc = create_info->pAllocCb;
++ instance->allocator = *allocator;
+ instance->physical_device.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
+
+ *out_instance = instance;
+@@ -244,8 +244,9 @@ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) {
+ // -----------------------------------------------------------------------------
+ // Instance
+
+-void DestroyInstance(VkInstance instance) {
+- instance->alloc->pfnFree(instance->alloc->pUserData, instance);
++void DestroyInstance(VkInstance instance,
++ const VkAllocCallbacks* /*allocator*/) {
++ instance->allocator.pfnFree(instance->allocator.pUserData, instance);
+ }
+
+ // -----------------------------------------------------------------------------
+@@ -302,15 +303,19 @@ void GetPhysicalDeviceMemoryProperties(
+
+ VkResult CreateDevice(VkPhysicalDevice physical_device,
+ const VkDeviceCreateInfo*,
++ const VkAllocCallbacks* allocator,
+ VkDevice* out_device) {
+ VkInstance_T* instance = GetInstanceFromPhysicalDevice(physical_device);
+- VkDevice_T* device = static_cast<VkDevice_T*>(instance->alloc->pfnAlloc(
+- instance->alloc->pUserData, sizeof(VkDevice_T), alignof(VkDevice_T),
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
++ if (!allocator)
++ allocator = &instance->allocator;
++ VkDevice_T* device = static_cast<VkDevice_T*>(
++ allocator->pfnAlloc(allocator->pUserData, sizeof(VkDevice_T),
++ alignof(VkDevice_T), VK_SYSTEM_ALLOC_SCOPE_DEVICE));
+ if (!device)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ device->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
++ device->allocator = *allocator;
+ device->instance = instance;
+ device->queue.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
+ std::fill(device->next_handle.begin(), device->next_handle.end(),
+@@ -320,11 +325,10 @@ VkResult CreateDevice(VkPhysicalDevice physical_device,
+ return VK_SUCCESS;
+ }
+
+-void DestroyDevice(VkDevice device) {
++void DestroyDevice(VkDevice device, const VkAllocCallbacks* /*allocator*/) {
+ if (!device)
+ return;
+- const VkAllocCallbacks* alloc = device->instance->alloc;
+- alloc->pfnFree(alloc->pUserData, device);
++ device->allocator.pfnFree(device->allocator.pUserData, device);
+ }
+
+ void GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
+@@ -332,19 +336,50 @@ void GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
+ }
+
+ // -----------------------------------------------------------------------------
++// CmdPool
++
++struct CmdPool {
++ typedef VkCmdPool HandleType;
++ VkAllocCallbacks allocator;
++};
++DEFINE_OBJECT_HANDLE_CONVERSION(CmdPool)
++
++VkResult CreateCommandPool(VkDevice device,
++ const VkCmdPoolCreateInfo* /*create_info*/,
++ const VkAllocCallbacks* allocator,
++ VkCmdPool* cmd_pool) {
++ if (!allocator)
++ allocator = &device->allocator;
++ CmdPool* pool = static_cast<CmdPool*>(
++ allocator->pfnAlloc(allocator->pUserData, sizeof(CmdPool),
++ alignof(CmdPool), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
++ if (!pool)
++ return VK_ERROR_OUT_OF_HOST_MEMORY;
++ pool->allocator = *allocator;
++ *cmd_pool = GetHandleToCmdPool(pool);
++ return VK_SUCCESS;
++}
++
++void DestroyCommandPool(VkDevice /*device*/,
++ VkCmdPool cmd_pool,
++ const VkAllocCallbacks* /*allocator*/) {
++ CmdPool* pool = GetCmdPoolFromHandle(cmd_pool);
++ pool->allocator.pfnFree(pool->allocator.pUserData, pool);
++}
++
++// -----------------------------------------------------------------------------
+ // CmdBuffer
+
+-VkResult AllocCommandBuffers(VkDevice device,
++VkResult AllocCommandBuffers(VkDevice /*device*/,
+ const VkCmdBufferAllocInfo* alloc_info,
+ VkCmdBuffer* cmdbufs) {
+ VkResult result = VK_SUCCESS;
+- const VkAllocCallbacks* alloc = device->instance->alloc;
+-
+- std::fill(cmdbufs, cmdbufs + alloc_info->count, nullptr);
+- for (uint32_t i = 0; i < alloc_info->count; i++) {
+- cmdbufs[i] = static_cast<VkCmdBuffer_T*>(alloc->pfnAlloc(
+- alloc->pUserData, sizeof(VkCmdBuffer_T), alignof(VkCmdBuffer_T),
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
++ CmdPool& pool = *GetCmdPoolFromHandle(alloc_info->cmdPool);
++ std::fill(cmdbufs, cmdbufs + alloc_info->bufferCount, nullptr);
++ for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
++ cmdbufs[i] = static_cast<VkCmdBuffer_T*>(pool.allocator.pfnAlloc(
++ pool.allocator.pUserData, sizeof(VkCmdBuffer_T),
++ alignof(VkCmdBuffer_T), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+ if (!cmdbufs[i]) {
+ result = VK_ERROR_OUT_OF_HOST_MEMORY;
+ break;
+@@ -352,23 +387,22 @@ VkResult AllocCommandBuffers(VkDevice device,
+ cmdbufs[i]->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
+ }
+ if (result != VK_SUCCESS) {
+- for (uint32_t i = 0; i < alloc_info->count; i++) {
++ for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
+ if (!cmdbufs[i])
+ break;
+- alloc->pfnFree(alloc->pUserData, cmdbufs[i]);
++ pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
+ }
+ }
+-
+ return result;
+ }
+
+-void FreeCommandBuffers(VkDevice device,
+- VkCmdPool,
++void FreeCommandBuffers(VkDevice /*device*/,
++ VkCmdPool cmd_pool,
+ uint32_t count,
+ const VkCmdBuffer* cmdbufs) {
+- const VkAllocCallbacks* alloc = device->instance->alloc;
++ CmdPool& pool = *GetCmdPoolFromHandle(cmd_pool);
+ for (uint32_t i = 0; i < count; i++)
+- alloc->pfnFree(alloc->pUserData, cmdbufs[i]);
++ pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
+ }
+
+ // -----------------------------------------------------------------------------
+@@ -383,15 +417,17 @@ DEFINE_OBJECT_HANDLE_CONVERSION(DeviceMemory)
+
+ VkResult AllocMemory(VkDevice device,
+ const VkMemoryAllocInfo* alloc_info,
++ const VkAllocCallbacks* allocator,
+ VkDeviceMemory* mem_handle) {
+ if (SIZE_MAX - sizeof(DeviceMemory) <= alloc_info->allocationSize)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
++ if (!allocator)
++ allocator = &device->allocator;
+
+- const VkAllocCallbacks* alloc = device->instance->alloc;
+ size_t size = sizeof(DeviceMemory) + size_t(alloc_info->allocationSize);
+ DeviceMemory* mem = static_cast<DeviceMemory*>(
+- alloc->pfnAlloc(alloc->pUserData, size, alignof(DeviceMemory),
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
++ allocator->pfnAlloc(allocator->pUserData, size, alignof(DeviceMemory),
++ VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+ if (!mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ mem->size = size;
+@@ -399,10 +435,13 @@ VkResult AllocMemory(VkDevice device,
+ return VK_SUCCESS;
+ }
+
+-void FreeMemory(VkDevice device, VkDeviceMemory mem_handle) {
+- const VkAllocCallbacks* alloc = device->instance->alloc;
++void FreeMemory(VkDevice device,
++ VkDeviceMemory mem_handle,
++ const VkAllocCallbacks* allocator) {
++ if (!allocator)
++ allocator = &device->allocator;
+ DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
+- alloc->pfnFree(alloc->pUserData, mem);
++ allocator->pfnFree(allocator->pUserData, mem);
+ }
+
+ VkResult MapMemory(VkDevice,
+@@ -427,16 +466,17 @@ DEFINE_OBJECT_HANDLE_CONVERSION(Buffer)
+
+ VkResult CreateBuffer(VkDevice device,
+ const VkBufferCreateInfo* create_info,
++ const VkAllocCallbacks* allocator,
+ VkBuffer* buffer_handle) {
+ ALOGW_IF(create_info->size > kMaxDeviceMemory,
+ "CreateBuffer: requested size 0x%" PRIx64
+ " exceeds max device memory size 0x%" PRIx64,
+ create_info->size, kMaxDeviceMemory);
+-
+- const VkAllocCallbacks* alloc = device->instance->alloc;
++ if (!allocator)
++ allocator = &device->allocator;
+ Buffer* buffer = static_cast<Buffer*>(
+- alloc->pfnAlloc(alloc->pUserData, sizeof(Buffer), alignof(Buffer),
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
++ allocator->pfnAlloc(allocator->pUserData, sizeof(Buffer),
++ alignof(Buffer), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+ if (!buffer)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ buffer->size = create_info->size;
+@@ -453,10 +493,13 @@ void GetBufferMemoryRequirements(VkDevice,
+ requirements->memoryTypeBits = 0x1;
+ }
+
+-void DestroyBuffer(VkDevice device, VkBuffer buffer_handle) {
+- const VkAllocCallbacks* alloc = device->instance->alloc;
++void DestroyBuffer(VkDevice device,
++ VkBuffer buffer_handle,
++ const VkAllocCallbacks* allocator) {
++ if (!allocator)
++ allocator = &device->allocator;
+ Buffer* buffer = GetBufferFromHandle(buffer_handle);
+- alloc->pfnFree(alloc->pUserData, buffer);
++ allocator->pfnFree(allocator->pUserData, buffer);
+ }
+
+ // -----------------------------------------------------------------------------
+@@ -470,6 +513,7 @@ DEFINE_OBJECT_HANDLE_CONVERSION(Image)
+
+ VkResult CreateImage(VkDevice device,
+ const VkImageCreateInfo* create_info,
++ const VkAllocCallbacks* allocator,
+ VkImage* image_handle) {
+ if (create_info->imageType != VK_IMAGE_TYPE_2D ||
+ create_info->format != VK_FORMAT_R8G8B8A8_UNORM ||
+@@ -488,10 +532,11 @@ VkResult CreateImage(VkDevice device,
+ " exceeds max device memory size 0x%" PRIx64,
+ size, kMaxDeviceMemory);
+
+- const VkAllocCallbacks* alloc = device->instance->alloc;
++ if (!allocator)
++ allocator = &device->allocator;
+ Image* image = static_cast<Image*>(
+- alloc->pfnAlloc(alloc->pUserData, sizeof(Image), alignof(Image),
+- VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
++ allocator->pfnAlloc(allocator->pUserData, sizeof(Image), alignof(Image),
++ VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+ if (!image)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ image->size = size;
+@@ -508,10 +553,13 @@ void GetImageMemoryRequirements(VkDevice,
+ requirements->memoryTypeBits = 0x1;
+ }
+
+-void DestroyImage(VkDevice device, VkImage image_handle) {
+- const VkAllocCallbacks* alloc = device->instance->alloc;
++void DestroyImage(VkDevice device,
++ VkImage image_handle,
++ const VkAllocCallbacks* allocator) {
++ if (!allocator)
++ allocator = &device->allocator;
+ Image* image = GetImageFromHandle(image_handle);
+- alloc->pfnFree(alloc->pUserData, image);
++ allocator->pfnFree(allocator->pUserData, image);
+ }
+
+ // -----------------------------------------------------------------------------
+@@ -519,20 +567,15 @@ void DestroyImage(VkDevice device, VkImage image_handle) {
+
+ VkResult CreateBufferView(VkDevice device,
+ const VkBufferViewCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkBufferView* view) {
+ *view = AllocHandle(device, HandleType::kBufferView);
+ return VK_SUCCESS;
+ }
+
+-VkResult CreateCommandPool(VkDevice device,
+- const VkCmdPoolCreateInfo*,
+- VkCmdPool* pool) {
+- *pool = AllocHandle(device, HandleType::kCmdPool);
+- return VK_SUCCESS;
+-}
+-
+ VkResult CreateDescriptorPool(VkDevice device,
+ const VkDescriptorPoolCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkDescriptorPool* pool) {
+ *pool = AllocHandle(device, HandleType::kDescriptorPool);
+ return VK_SUCCESS;
+@@ -541,13 +584,14 @@ VkResult CreateDescriptorPool(VkDevice device,
+ VkResult AllocDescriptorSets(VkDevice device,
+ const VkDescriptorSetAllocInfo* alloc_info,
+ VkDescriptorSet* descriptor_sets) {
+- for (uint32_t i = 0; i < alloc_info->count; i++)
++ for (uint32_t i = 0; i < alloc_info->setLayoutCount; i++)
+ descriptor_sets[i] = AllocHandle(device, HandleType::kDescriptorSet);
+ return VK_SUCCESS;
+ }
+
+ VkResult CreateDescriptorSetLayout(VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkDescriptorSetLayout* layout) {
+ *layout = AllocHandle(device, HandleType::kDescriptorSetLayout);
+ return VK_SUCCESS;
+@@ -555,6 +599,7 @@ VkResult CreateDescriptorSetLayout(VkDevice device,
+
+ VkResult CreateEvent(VkDevice device,
+ const VkEventCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkEvent* event) {
+ *event = AllocHandle(device, HandleType::kEvent);
+ return VK_SUCCESS;
+@@ -562,6 +607,7 @@ VkResult CreateEvent(VkDevice device,
+
+ VkResult CreateFence(VkDevice device,
+ const VkFenceCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkFence* fence) {
+ *fence = AllocHandle(device, HandleType::kFence);
+ return VK_SUCCESS;
+@@ -569,6 +615,7 @@ VkResult CreateFence(VkDevice device,
+
+ VkResult CreateFramebuffer(VkDevice device,
+ const VkFramebufferCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkFramebuffer* framebuffer) {
+ *framebuffer = AllocHandle(device, HandleType::kFramebuffer);
+ return VK_SUCCESS;
+@@ -576,6 +623,7 @@ VkResult CreateFramebuffer(VkDevice device,
+
+ VkResult CreateImageView(VkDevice device,
+ const VkImageViewCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkImageView* view) {
+ *view = AllocHandle(device, HandleType::kImageView);
+ return VK_SUCCESS;
+@@ -585,6 +633,7 @@ VkResult CreateGraphicsPipelines(VkDevice device,
+ VkPipelineCache,
+ uint32_t count,
+ const VkGraphicsPipelineCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkPipeline* pipelines) {
+ for (uint32_t i = 0; i < count; i++)
+ pipelines[i] = AllocHandle(device, HandleType::kPipeline);
+@@ -595,6 +644,7 @@ VkResult CreateComputePipelines(VkDevice device,
+ VkPipelineCache,
+ uint32_t count,
+ const VkComputePipelineCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkPipeline* pipelines) {
+ for (uint32_t i = 0; i < count; i++)
+ pipelines[i] = AllocHandle(device, HandleType::kPipeline);
+@@ -603,6 +653,7 @@ VkResult CreateComputePipelines(VkDevice device,
+
+ VkResult CreatePipelineCache(VkDevice device,
+ const VkPipelineCacheCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkPipelineCache* cache) {
+ *cache = AllocHandle(device, HandleType::kPipelineCache);
+ return VK_SUCCESS;
+@@ -610,6 +661,7 @@ VkResult CreatePipelineCache(VkDevice device,
+
+ VkResult CreatePipelineLayout(VkDevice device,
+ const VkPipelineLayoutCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkPipelineLayout* layout) {
+ *layout = AllocHandle(device, HandleType::kPipelineLayout);
+ return VK_SUCCESS;
+@@ -617,6 +669,7 @@ VkResult CreatePipelineLayout(VkDevice device,
+
+ VkResult CreateQueryPool(VkDevice device,
+ const VkQueryPoolCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkQueryPool* pool) {
+ *pool = AllocHandle(device, HandleType::kQueryPool);
+ return VK_SUCCESS;
+@@ -624,6 +677,7 @@ VkResult CreateQueryPool(VkDevice device,
+
+ VkResult CreateRenderPass(VkDevice device,
+ const VkRenderPassCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkRenderPass* renderpass) {
+ *renderpass = AllocHandle(device, HandleType::kRenderPass);
+ return VK_SUCCESS;
+@@ -631,6 +685,7 @@ VkResult CreateRenderPass(VkDevice device,
+
+ VkResult CreateSampler(VkDevice device,
+ const VkSamplerCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkSampler* sampler) {
+ *sampler = AllocHandle(device, HandleType::kSampler);
+ return VK_SUCCESS;
+@@ -638,6 +693,7 @@ VkResult CreateSampler(VkDevice device,
+
+ VkResult CreateSemaphore(VkDevice device,
+ const VkSemaphoreCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkSemaphore* semaphore) {
+ *semaphore = AllocHandle(device, HandleType::kSemaphore);
+ return VK_SUCCESS;
+@@ -645,6 +701,7 @@ VkResult CreateSemaphore(VkDevice device,
+
+ VkResult CreateShader(VkDevice device,
+ const VkShaderCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkShader* shader) {
+ *shader = AllocHandle(device, HandleType::kShader);
+ return VK_SUCCESS;
+@@ -652,6 +709,7 @@ VkResult CreateShader(VkDevice device,
+
+ VkResult CreateShaderModule(VkDevice device,
+ const VkShaderModuleCreateInfo*,
++ const VkAllocCallbacks* /*allocator*/,
+ VkShaderModule* module) {
+ *module = AllocHandle(device, HandleType::kShaderModule);
+ return VK_SUCCESS;
+@@ -772,7 +830,7 @@ VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBi
+ return VK_SUCCESS;
+ }
+
+-void DestroyFence(VkDevice device, VkFence fence) {
++void DestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* allocator) {
+ }
+
+ VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
+@@ -788,10 +846,10 @@ VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFen
+ return VK_SUCCESS;
+ }
+
+-void DestroySemaphore(VkDevice device, VkSemaphore semaphore) {
++void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* allocator) {
+ }
+
+-void DestroyEvent(VkDevice device, VkEvent event) {
++void DestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* allocator) {
+ }
+
+ VkResult GetEventStatus(VkDevice device, VkEvent event) {
+@@ -809,7 +867,7 @@ VkResult ResetEvent(VkDevice device, VkEvent event) {
+ return VK_SUCCESS;
+ }
+
+-void DestroyQueryPool(VkDevice device, VkQueryPool queryPool) {
++void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* allocator) {
+ }
+
+ VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
+@@ -817,23 +875,23 @@ VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t st
+ return VK_SUCCESS;
+ }
+
+-void DestroyBufferView(VkDevice device, VkBufferView bufferView) {
++void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* allocator) {
+ }
+
+ void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ }
+
+-void DestroyImageView(VkDevice device, VkImageView imageView) {
++void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* allocator) {
+ }
+
+-void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule) {
++void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* allocator) {
+ }
+
+-void DestroyShader(VkDevice device, VkShader shader) {
++void DestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* allocator) {
+ }
+
+-void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache) {
++void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* allocator) {
+ }
+
+ VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
+@@ -846,19 +904,19 @@ VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_
+ return VK_SUCCESS;
+ }
+
+-void DestroyPipeline(VkDevice device, VkPipeline pipeline) {
++void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* allocator) {
+ }
+
+-void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout) {
++void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* allocator) {
+ }
+
+-void DestroySampler(VkDevice device, VkSampler sampler) {
++void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* allocator) {
+ }
+
+-void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout) {
++void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* allocator) {
+ }
+
+-void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {
++void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* allocator) {
+ }
+
+ VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
+@@ -875,19 +933,16 @@ VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, ui
+ return VK_SUCCESS;
+ }
+
+-void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer) {
++void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* allocator) {
+ }
+
+-void DestroyRenderPass(VkDevice device, VkRenderPass renderPass) {
++void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* allocator) {
+ }
+
+ void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ }
+
+-void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool) {
+-}
+-
+ VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ return VK_SUCCESS;
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index f07d61c..557d0db 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -27,7 +27,7 @@ PFN_vkVoidFunction LookupInstanceProcAddr(const char* name);
+ PFN_vkVoidFunction LookupDeviceProcAddr(const char* name);
+
+ // clang-format off
+-void DestroyInstance(VkInstance instance);
++void DestroyInstance(VkInstance instance, const VkAllocCallbacks* allocator);
+ VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+ void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+ void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+@@ -37,8 +37,8 @@ void GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uin
+ void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
+ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
+-VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
+-void DestroyDevice(VkDevice device);
++VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDevice* pDevice);
++void DestroyDevice(VkDevice device, const VkAllocCallbacks* allocator);
+ VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+ VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+ VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);
+@@ -47,8 +47,8 @@ void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIn
+ VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
+ VkResult QueueWaitIdle(VkQueue queue);
+ VkResult DeviceWaitIdle(VkDevice device);
+-VkResult AllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
+-void FreeMemory(VkDevice device, VkDeviceMemory mem);
++VkResult AllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* allocator, VkDeviceMemory* pMem);
++void FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* allocator);
+ VkResult MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
+ void UnmapMemory(VkDevice device, VkDeviceMemory mem);
+ VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+@@ -63,60 +63,60 @@ void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevic
+ VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+ VkResult QueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+ VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
+-VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
+-void DestroyFence(VkDevice device, VkFence fence);
++VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkFence* pFence);
++void DestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* allocator);
+ VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
+ VkResult GetFenceStatus(VkDevice device, VkFence fence);
+ VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
+-VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
+-void DestroySemaphore(VkDevice device, VkSemaphore semaphore);
+-VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
+-void DestroyEvent(VkDevice device, VkEvent event);
++VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkSemaphore* pSemaphore);
++void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* allocator);
++VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkEvent* pEvent);
++void DestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* allocator);
+ VkResult GetEventStatus(VkDevice device, VkEvent event);
+ VkResult SetEvent(VkDevice device, VkEvent event);
+ VkResult ResetEvent(VkDevice device, VkEvent event);
+-VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
+-void DestroyQueryPool(VkDevice device, VkQueryPool queryPool);
++VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkQueryPool* pQueryPool);
++void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* allocator);
+ VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+-VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
+-void DestroyBuffer(VkDevice device, VkBuffer buffer);
+-VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
+-void DestroyBufferView(VkDevice device, VkBufferView bufferView);
+-VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
+-void DestroyImage(VkDevice device, VkImage image);
++VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkBuffer* pBuffer);
++void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* allocator);
++VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkBufferView* pView);
++void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* allocator);
++VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkImage* pImage);
++void DestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* allocator);
+ void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+-VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
+-void DestroyImageView(VkDevice device, VkImageView imageView);
+-VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
+-void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule);
+-VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
+-void DestroyShader(VkDevice device, VkShader shader);
+-VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
+-void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache);
++VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkImageView* pView);
++void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* allocator);
++VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkShaderModule* pShaderModule);
++void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* allocator);
++VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkShader* pShader);
++void DestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* allocator);
++VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkPipelineCache* pPipelineCache);
++void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* allocator);
+ VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+ VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+-VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+-VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+-void DestroyPipeline(VkDevice device, VkPipeline pipeline);
+-VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
+-void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout);
+-VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
+-void DestroySampler(VkDevice device, VkSampler sampler);
+-VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
+-void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
+-VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
+-void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool);
++VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* allocator, VkPipeline* pPipelines);
++VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* allocator, VkPipeline* pPipelines);
++void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* allocator);
++VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkPipelineLayout* pPipelineLayout);
++void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* allocator);
++VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkSampler* pSampler);
++void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* allocator);
++VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDescriptorSetLayout* pSetLayout);
++void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* allocator);
++VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDescriptorPool* pDescriptorPool);
++void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* allocator);
+ VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+ VkResult AllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
+ VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
+ void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+-VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
+-void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer);
+-VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
+-void DestroyRenderPass(VkDevice device, VkRenderPass renderPass);
++VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkFramebuffer* pFramebuffer);
++void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* allocator);
++VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkRenderPass* pRenderPass);
++void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* allocator);
+ void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+-VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
+-void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool);
++VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkCmdPool* pCmdPool);
++void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* allocator);
+ VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
+ VkResult AllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
+ void FreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers);
+diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
+index f92b62c..63e0d5f 100644
+--- a/vulkan/tools/vkinfo.cpp
++++ b/vulkan/tools/vkinfo.cpp
+@@ -158,13 +158,12 @@ int main(int /*argc*/, char const* /*argv*/ []) {
+ .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+ .pNext = nullptr,
+ .pAppInfo = nullptr,
+- .pAllocCb = nullptr,
+- .layerCount = 0,
++ .enabledLayerNameCount = 0,
+ .ppEnabledLayerNames = nullptr,
+- .extensionCount = 0,
++ .enabledExtensionNameCount = 0,
+ .ppEnabledExtensionNames = nullptr,
+ };
+- result = vkCreateInstance(&create_info, &instance);
++ result = vkCreateInstance(&create_info, nullptr, &instance);
+ if (result != VK_SUCCESS)
+ die("vkCreateInstance", result);
+
+@@ -189,7 +188,7 @@ int main(int /*argc*/, char const* /*argv*/ []) {
+ for (uint32_t i = 0; i < physical_devices.size(); i++)
+ DumpPhysicalDevice(i, physical_devices[i]);
+
+- vkDestroyInstance(instance);
++ vkDestroyInstance(instance, nullptr);
+
+ return 0;
+ }
+--
+2.4.0
+
--- /dev/null
+From 5dd913c12f8eccf523b4588806711e3b45ed8b79 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Sun, 29 Nov 2015 14:36:39 -0800
+Subject: [PATCH 13/30] vulkan: Update from version 0.188.0 to 0.189.0
+
+Change-Id: Ib8171ce1d3f804f9a866e1c216db0911043056c6
+---
+ vulkan/api/vulkan.api | 42 +++++++++++++-------------
+ vulkan/include/vulkan/vulkan.h | 68 +++++++++++++++++++++---------------------
+ vulkan/libvulkan/entry.cpp | 2 +-
+ vulkan/nulldrv/null_driver.cpp | 2 +-
+ vulkan/nulldrv/null_driver.h | 2 +-
+ 5 files changed, 58 insertions(+), 58 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index b95c96e..5d0a7f8 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 188
++define VERSION_MINOR 189
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -256,23 +256,23 @@ enum VkIndexType {
+ VK_INDEX_TYPE_UINT32 = 0x00000001,
+ }
+
+-enum VkTexFilter {
+- VK_TEX_FILTER_NEAREST = 0x00000000,
+- VK_TEX_FILTER_LINEAR = 0x00000001,
++enum VkFilter {
++ VK_FILTER_NEAREST = 0x00000000,
++ VK_FILTER_LINEAR = 0x00000001,
+ }
+
+-enum VkTexMipmapMode {
+- VK_TEX_MIPMAP_MODE_BASE = 0x00000000, /// Always choose base level
+- VK_TEX_MIPMAP_MODE_NEAREST = 0x00000001, /// Choose nearest mip level
+- VK_TEX_MIPMAP_MODE_LINEAR = 0x00000002, /// Linear filter between mip levels
++enum VkSamplerMipmapMode {
++ VK_SAMPLER_MIPMAP_MODE_BASE = 0x00000000, /// Always choose base level
++ VK_SAMPLER_MIPMAP_MODE_NEAREST = 0x00000001, /// Choose nearest mip level
++ VK_SAMPLER_MIPMAP_MODE_LINEAR = 0x00000002, /// Linear filter between mip levels
+ }
+
+-enum VkTexAddressMode {
+- VK_TEX_ADDRESS_MODE_WRAP = 0x00000000,
+- VK_TEX_ADDRESS_MODE_MIRROR = 0x00000001,
+- VK_TEX_ADDRESS_MODE_CLAMP = 0x00000002,
+- VK_TEX_ADDRESS_MODE_MIRROR_ONCE = 0x00000003,
+- VK_TEX_ADDRESS_MODE_CLAMP_BORDER = 0x00000004,
++enum VkSamplerAddressMode {
++ VK_SAMPLER_ADDRESS_MODE_WRAP = 0x00000000,
++ VK_SAMPLER_ADDRESS_MODE_MIRROR = 0x00000001,
++ VK_SAMPLER_ADDRESS_MODE_CLAMP = 0x00000002,
++ VK_SAMPLER_ADDRESS_MODE_MIRROR_ONCE = 0x00000003,
++ VK_SAMPLER_ADDRESS_MODE_CLAMP_BORDER = 0x00000004,
+ }
+
+ enum VkCompareOp {
+@@ -1730,12 +1730,12 @@ class VkPipelineLayoutCreateInfo {
+ class VkSamplerCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- VkTexFilter magFilter /// Filter mode for magnification
+- VkTexFilter minFilter /// Filter mode for minifiation
+- VkTexMipmapMode mipMode /// Mipmap selection mode
+- VkTexAddressMode addressModeU
+- VkTexAddressMode addressModeV
+- VkTexAddressMode addressModeW
++ VkFilter magFilter /// Filter mode for magnification
++ VkFilter minFilter /// Filter mode for minifiation
++ VkSamplerMipmapMode mipmapMode /// Mipmap selection mode
++ VkSamplerAddressMode addressModeU
++ VkSamplerAddressMode addressModeV
++ VkSamplerAddressMode addressModeW
+ f32 mipLodBias
+ f32 maxAnisotropy
+ VkBool32 compareEnable
+@@ -4089,7 +4089,7 @@ cmd void vkCmdBlitImage(
+ VkImageLayout destImageLayout,
+ u32 regionCount,
+ const VkImageBlit* pRegions,
+- VkTexFilter filter) {
++ VkFilter filter) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ srcImageObject := GetImage(srcImage)
+ destImageObject := GetImage(destImage)
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index d061988..dc977e5 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 188, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 189, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -647,35 +647,35 @@ typedef enum {
+ } VkDynamicState;
+
+ typedef enum {
+- VK_TEX_FILTER_NEAREST = 0,
+- VK_TEX_FILTER_LINEAR = 1,
+- VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST,
+- VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR,
+- VK_TEX_FILTER_NUM = (VK_TEX_FILTER_LINEAR - VK_TEX_FILTER_NEAREST + 1),
+- VK_TEX_FILTER_MAX_ENUM = 0x7FFFFFFF
+-} VkTexFilter;
++ VK_FILTER_NEAREST = 0,
++ VK_FILTER_LINEAR = 1,
++ VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
++ VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
++ VK_FILTER_NUM = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
++ VK_FILTER_MAX_ENUM = 0x7FFFFFFF
++} VkFilter;
+
+ typedef enum {
+- VK_TEX_MIPMAP_MODE_BASE = 0,
+- VK_TEX_MIPMAP_MODE_NEAREST = 1,
+- VK_TEX_MIPMAP_MODE_LINEAR = 2,
+- VK_TEX_MIPMAP_MODE_BEGIN_RANGE = VK_TEX_MIPMAP_MODE_BASE,
+- VK_TEX_MIPMAP_MODE_END_RANGE = VK_TEX_MIPMAP_MODE_LINEAR,
+- VK_TEX_MIPMAP_MODE_NUM = (VK_TEX_MIPMAP_MODE_LINEAR - VK_TEX_MIPMAP_MODE_BASE + 1),
+- VK_TEX_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
+-} VkTexMipmapMode;
++ VK_SAMPLER_MIPMAP_MODE_BASE = 0,
++ VK_SAMPLER_MIPMAP_MODE_NEAREST = 1,
++ VK_SAMPLER_MIPMAP_MODE_LINEAR = 2,
++ VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_BASE,
++ VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
++ VK_SAMPLER_MIPMAP_MODE_NUM = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_BASE + 1),
++ VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
++} VkSamplerMipmapMode;
+
+ typedef enum {
+- VK_TEX_ADDRESS_MODE_WRAP = 0,
+- VK_TEX_ADDRESS_MODE_MIRROR = 1,
+- VK_TEX_ADDRESS_MODE_CLAMP = 2,
+- VK_TEX_ADDRESS_MODE_MIRROR_ONCE = 3,
+- VK_TEX_ADDRESS_MODE_CLAMP_BORDER = 4,
+- VK_TEX_ADDRESS_MODE_BEGIN_RANGE = VK_TEX_ADDRESS_MODE_WRAP,
+- VK_TEX_ADDRESS_MODE_END_RANGE = VK_TEX_ADDRESS_MODE_CLAMP_BORDER,
+- VK_TEX_ADDRESS_MODE_NUM = (VK_TEX_ADDRESS_MODE_CLAMP_BORDER - VK_TEX_ADDRESS_MODE_WRAP + 1),
+- VK_TEX_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
+-} VkTexAddressMode;
++ VK_SAMPLER_ADDRESS_MODE_WRAP = 0,
++ VK_SAMPLER_ADDRESS_MODE_MIRROR = 1,
++ VK_SAMPLER_ADDRESS_MODE_CLAMP = 2,
++ VK_SAMPLER_ADDRESS_MODE_MIRROR_ONCE = 3,
++ VK_SAMPLER_ADDRESS_MODE_CLAMP_BORDER = 4,
++ VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_WRAP,
++ VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_BORDER,
++ VK_SAMPLER_ADDRESS_MODE_NUM = (VK_SAMPLER_ADDRESS_MODE_CLAMP_BORDER - VK_SAMPLER_ADDRESS_MODE_WRAP + 1),
++ VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
++} VkSamplerAddressMode;
+
+ typedef enum {
+ VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
+@@ -1756,12 +1756,12 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkTexFilter magFilter;
+- VkTexFilter minFilter;
+- VkTexMipmapMode mipMode;
+- VkTexAddressMode addressModeU;
+- VkTexAddressMode addressModeV;
+- VkTexAddressMode addressModeW;
++ VkFilter magFilter;
++ VkFilter minFilter;
++ VkSamplerMipmapMode mipmapMode;
++ VkSamplerAddressMode addressModeU;
++ VkSamplerAddressMode addressModeV;
++ VkSamplerAddressMode addressModeW;
+ float mipLodBias;
+ float maxAnisotropy;
+ VkBool32 compareEnable;
+@@ -2194,7 +2194,7 @@ typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint3
+ typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
+ typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+ typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+-typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter);
++typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+ typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+ typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+ typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
+@@ -2880,7 +2880,7 @@ void VKAPI vkCmdBlitImage(
+ VkImageLayout destImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+- VkTexFilter filter);
++ VkFilter filter);
+
+ void VKAPI vkCmdCopyBufferToImage(
+ VkCmdBuffer cmdBuffer,
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 7622e4d..386acbf 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -632,7 +632,7 @@ void vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcIm
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter) {
++void vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+ GetVtbl(cmdBuffer).CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+ }
+
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index fe6a1e8..9c56982 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -1024,7 +1024,7 @@ void CmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffe
+ void CmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
+ }
+
+-void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter) {
++void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+ }
+
+ void CmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 557d0db..dd6dc6b 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -144,7 +144,7 @@ void CmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
+ void CmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
+ void CmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+ void CmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+-void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter);
++void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+ void CmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+ void CmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+ void CmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
+--
+2.4.0
+
--- /dev/null
+From ef949b4f570c963e3d4e8362b3a6a3d41f3ce4b8 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Sun, 29 Nov 2015 18:59:42 -0800
+Subject: [PATCH 14/30] vulkan: Update from version 0.189.0 to 0.190.0
+
+Change-Id: I0ac3f2797b65ef49cca90e76a47f1e6ca3a341a3
+---
+ vulkan/api/platform.api | 4 +-
+ vulkan/api/vulkan.api | 408 ++++++++++++++++++++++++--------
+ vulkan/include/vulkan/vk_platform.h | 2 +-
+ vulkan/include/vulkan/vulkan.h | 303 ++++++++++++++++--------
+ vulkan/libvulkan/entry.cpp | 16 +-
+ vulkan/libvulkan/get_proc_addr.cpp | 24 +-
+ vulkan/libvulkan/get_proc_addr.cpp.tmpl | 2 +-
+ vulkan/libvulkan/loader.h | 6 +-
+ vulkan/libvulkan/swapchain.cpp | 4 +-
+ vulkan/nulldrv/null_driver.cpp | 12 +-
+ vulkan/nulldrv/null_driver.h | 4 +-
+ vulkan/nulldrv/null_driver_gen.cpp | 4 +-
+ 12 files changed, 541 insertions(+), 248 deletions(-)
+
+diff --git a/vulkan/api/platform.api b/vulkan/api/platform.api
+index 889ac2c..980722d 100644
+--- a/vulkan/api/platform.api
++++ b/vulkan/api/platform.api
+@@ -23,13 +23,15 @@
+
+ type u64 size_t
+
+-// VK_USE_PLATFORM_X11_KHR
++// VK_USE_PLATFORM_XLIB_KHR
+ @internal class Display {}
+ @internal class Window {}
++@internal type u64 VisualID
+
+ // VK_USE_PLATFORM_XCB_KHR
+ @internal class xcb_connection_t {}
+ @internal type u32 xcb_window_t
++@internal type u32 xcb_visualid_t
+
+ // VK_USE_PLATFORM_WAYLAND_KHR
+ @internal class wl_display {}
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 5d0a7f8..0c6a3cc 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 189
++define VERSION_MINOR 190
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -45,35 +45,35 @@ define VK_FALSE 0
+ // API keyword, but needs special handling by some templates
+ define NULL_HANDLE 0
+
+-@extension("VK_EXT_KHR_surface") define VK_EXT_KHR_SURFACE_REVISION 19
++@extension("VK_EXT_KHR_surface") define VK_EXT_KHR_SURFACE_REVISION 20
+ @extension("VK_EXT_KHR_surface") define VK_EXT_KHR_SURFACE_EXTENSION_NUMBER 1
+ @extension("VK_EXT_KHR_surface") define VK_EXT_KHR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_surface"
+
+-@extension("VK_EXT_KHR_swapchain") define VK_EXT_KHR_SWAPCHAIN_REVISION 59
++@extension("VK_EXT_KHR_swapchain") define VK_EXT_KHR_SWAPCHAIN_REVISION 62
+ @extension("VK_EXT_KHR_swapchain") define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+ @extension("VK_EXT_KHR_swapchain") define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
+
+-@extension("VK_EXT_KHR_display") define VK_EXT_KHR_DISPLAY_REVISION 16
++@extension("VK_EXT_KHR_display") define VK_EXT_KHR_DISPLAY_REVISION 17
+ @extension("VK_EXT_KHR_display") define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 3
+ @extension("VK_EXT_KHR_display") define VK_EXT_KHR_DISPLAY_EXTENSION_NAME "VK_EXT_KHR_display"
+
+-@extension("VK_EXT_KHR_display_swapchain") define VK_EXT_KHR_DISPLAY_REVISION 14
++@extension("VK_EXT_KHR_display_swapchain") define VK_EXT_KHR_DISPLAY_REVISION 6
+ @extension("VK_EXT_KHR_display_swapchain") define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 4
+ @extension("VK_EXT_KHR_display_swapchain") define VK_EXT_KHR_DISPLAY_EXTENSION_NAME "VK_EXT_KHR_display_swapchain"
+
+-@extension("VK_EXT_KHR_x11_surface") define VK_EXT_KHR_X11_SURFACE_REVISION 1
+-@extension("VK_EXT_KHR_x11_surface") define VK_EXT_KHR_X11_SURFACE_NUMBER 4
+-@extension("VK_EXT_KHR_x11_surface") define VK_EXT_KHR_X11_SURFACE_NAME "VK_EXT_KHR_x11_surface"
++@extension("VK_EXT_KHR_xlib_surface") define VK_EXT_KHR_XLIB_SURFACE_REVISION 3
++@extension("VK_EXT_KHR_xlib_surface") define VK_EXT_KHR_XLIB_SURFACE_NUMBER 5
++@extension("VK_EXT_KHR_xlib_surface") define VK_EXT_KHR_XLIB_SURFACE_NAME "VK_EXT_KHR_xlib_surface"
+
+-@extension("VK_EXT_KHR_xcb_surface") define VK_EXT_KHR_XCB_SURFACE_REVISION 1
++@extension("VK_EXT_KHR_xcb_surface") define VK_EXT_KHR_XCB_SURFACE_REVISION 3
+ @extension("VK_EXT_KHR_xcb_surface") define VK_EXT_KHR_XCB_SURFACE_NUMBER 6
+ @extension("VK_EXT_KHR_xcb_surface") define VK_EXT_KHR_XCB_SURFACE_NAME "VK_EXT_KHR_xcb_surface"
+
+-@extension("VK_EXT_KHR_wayland_surface") define VK_EXT_KHR_WAYLAND_SURFACE_REVISION 1
++@extension("VK_EXT_KHR_wayland_surface") define VK_EXT_KHR_WAYLAND_SURFACE_REVISION 2
+ @extension("VK_EXT_KHR_wayland_surface") define VK_EXT_KHR_WAYLAND_SURFACE_NUMBER 7
+ @extension("VK_EXT_KHR_wayland_surface") define VK_EXT_KHR_WAYLAND_SURFACE_NAME "VK_EXT_KHR_wayland_surface"
+
+-@extension("VK_EXT_KHR_mir_surface") define VK_EXT_KHR_MIR_SURFACE_REVISION 1
++@extension("VK_EXT_KHR_mir_surface") define VK_EXT_KHR_MIR_SURFACE_REVISION 2
+ @extension("VK_EXT_KHR_mir_surface") define VK_EXT_KHR_MIR_SURFACE_NUMBER 8
+ @extension("VK_EXT_KHR_mir_surface") define VK_EXT_KHR_MIR_SURFACE_NAME "VK_EXT_KHR_mir_surface"
+
+@@ -81,7 +81,7 @@ define NULL_HANDLE 0
+ @extension("VK_EXT_KHR_android_surface") define VK_EXT_KHR_ANDROID_SURFACE_NUMBER 8
+ @extension("VK_EXT_KHR_android_surface") define VK_EXT_KHR_ANDROID_SURFACE_NAME "VK_EXT_KHR_android_surface"
+
+-@extension("VK_EXT_KHR_win32_surface") define VK_EXT_KHR_WIN32_SURFACE_REVISION 1
++@extension("VK_EXT_KHR_win32_surface") define VK_EXT_KHR_WIN32_SURFACE_REVISION 2
+ @extension("VK_EXT_KHR_win32_surface") define VK_EXT_KHR_WIN32_SURFACE_NUMBER 9
+ @extension("VK_EXT_KHR_win32_surface") define VK_EXT_KHR_WIN32_SURFACE_NAME "VK_EXT_KHR_win32_surface"
+
+@@ -620,13 +620,14 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_SUBMIT_INFO = 48,
+ VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 49,
+ VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 50,
++ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 51,
+
+ //@extension("VK_EXT_KHR_swapchain")
+ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 0xc0000801,
+
+ //@extension("VK_EXT_KHR_display")
+ VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 0xc0000c00,
+- VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_DISPLAY_PLAN_KHR = 0xc0000c01,
++ VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 0xc0000c01,
+
+ //@extension("VK_EXT_KHR_display_swapchain")
+ VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR = 0xc0001000,
+@@ -663,6 +664,9 @@ enum VkResult {
+ VK_ERROR_FEATURE_NOT_PRESENT = 0xFFFFFFF8,
+ VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF7,
+
++ //@extension("VK_EXT_KHR_surface")
++ VK_ERROR_SURFACE_LOST_KHR = 0xC0000400,
++
+ //@extension("VK_EXT_KHR_swapchain")
+ VK_ERROR_OUT_OF_DATE_KHR = 0xC0000804,
+
+@@ -810,8 +814,8 @@ bitfield VkDescriptorPoolCreateFlagBits {
+
+ /// Descriptor pool reset flags
+ type VkFlags VkDescriptorPoolResetFlags
+-bitfield VkDescriptorPoolResetFlagBits {
+-}
++//bitfield VkDescriptorPoolResetFlagBits {
++//}
+
+ /// Image usage flags
+ type VkFlags VkImageUsageFlags
+@@ -868,8 +872,8 @@ bitfield VkFenceCreateFlagBits {
+
+ /// Semaphore creation flags
+ type VkFlags VkSemaphoreCreateFlags
+-bitfield VkSemaphoreCreateFlagBits {
+-}
++//bitfield VkSemaphoreCreateFlagBits {
++//}
+
+ /// Format capability flags
+ type VkFlags VkFormatFeatureFlags
+@@ -906,18 +910,18 @@ bitfield VkQueryResultFlagBits {
+
+ /// Shader module creation flags
+ type VkFlags VkShaderModuleCreateFlags
+-bitfield VkShaderModuleCreateFlagBits {
+-}
++//bitfield VkShaderModuleCreateFlagBits {
++//}
+
+ /// Shader creation flags
+ type VkFlags VkShaderCreateFlags
+-bitfield VkShaderCreateFlagBits {
+-}
++//bitfield VkShaderCreateFlagBits {
++//}
+
+ /// Event creation flags
+ type VkFlags VkEventCreateFlags
+-bitfield VkEventCreateFlagBits {
+-}
++//bitfield VkEventCreateFlagBits {
++//}
+
+ /// Command buffer usage flags
+ type VkFlags VkCmdBufferUsageFlags
+@@ -945,8 +949,8 @@ bitfield VkQueryPipelineStatisticFlagBits {
+
+ /// Memory mapping flags
+ type VkFlags VkMemoryMapFlags
+-bitfield VkMemoryMapFlagBits {
+-}
++//bitfield VkMemoryMapFlagBits {
++//}
+
+ /// Bitfield of image aspects
+ type VkFlags VkImageAspectFlags
+@@ -1040,6 +1044,111 @@ bitfield VkStencilFaceFlagBits {
+ VK_STENCIL_FACE_BACK_BIT = 0x00000002, /// Back face
+ }
+
++/// Instance creation flags
++type VkFlags VkInstanceCreateFlags
++//bitfield VkInstanceCreateFlagBits {
++//}
++
++/// Device creation flags
++type VkFlags VkDeviceCreateFlags
++//bitfield VkDeviceCreateFlagBits {
++//}
++
++/// Device queue creation flags
++type VkFlags VkDeviceQueueCreateFlags
++//bitfield VkDeviceQueueCreateFlagBits {
++//}
++
++/// Query pool creation flags
++type VkFlags VkQueryPoolCreateFlags
++//bitfield VkQueryPoolCreateFlagBits {
++//}
++
++/// Buffer view creation flags
++type VkFlags VkBufferViewCreateFlags
++//bitfield VkBufferViewCreateFlagBits {
++//}
++
++/// Pipeline cache creation flags
++type VkFlags VkPipelineCacheCreateFlags
++//bitfield VkPipelineCacheCreateFlagBits {
++//}
++
++/// Pipeline shader stage creation flags
++type VkFlags VkPipelineShaderStageCreateFlags
++//bitfield VkPipelineShaderStageCreateFlagBits {
++//}
++
++/// Descriptor set layout creation flags
++type VkFlags VkDescriptorSetLayoutCreateFlags
++//bitfield VkDescriptorSetLayoutCreateFlagBits {
++//}
++
++/// Pipeline vertex input state creation flags
++type VkFlags VkPipelineVertexInputStateCreateFlags
++//bitfield VkPipelineVertexInputStateCreateFlagBits {
++//}
++
++/// Pipeline input assembly state creation flags
++type VkFlags VkPipelineInputAssemblyStateCreateFlags
++//bitfield VkPipelineInputAssemblyStateCreateFlagBits {
++//}
++
++/// Tessellation state creation flags
++type VkFlags VkPipelineTessellationStateCreateFlags
++//bitfield VkPipelineTessellationStateCreateFlagBits {
++//}
++
++/// Viewport state creation flags
++type VkFlags VkPipelineViewportStateCreateFlags
++//bitfield VkPipelineViewportStateCreateFlagBits {
++//}
++
++/// Raster state creation flags
++type VkFlags VkPipelineRasterStateCreateFlags
++//bitfield VkPipelineRasterStateCreateFlagBits {
++//}
++
++/// Multisample state creation flags
++type VkFlags VkPipelineMultisampleStateCreateFlags
++//bitfield VkPipelineMultisampleStateCreateFlagBits {
++//}
++
++/// Color blend state creation flags
++type VkFlags VkPipelineColorBlendStateCreateFlags
++//bitfield VkPipelineColorBlendStateCreateFlagBits {
++//}
++
++/// Depth/stencil state creation flags
++type VkFlags VkPipelineDepthStencilStateCreateFlags
++//bitfield VkPipelineDepthStencilStateCreateFlagBits {
++//}
++
++/// Dynamic state creation flags
++type VkFlags VkPipelineDynamicStateCreateFlags
++//bitfield VkPipelineDynamicStateCreateFlagBits {
++//}
++
++/// Pipeline layout creation flags
++type VkFlags VkPipelineLayoutCreateFlags
++//bitfield VkPipelineLayoutCreateFlagBits {
++//}
++
++/// Sampler creation flags
++type VkFlags VkSamplerCreateFlags
++//bitfield VkSamplerCreateFlagBits {
++//}
++
++/// Render pass creation flags
++type VkFlags VkRenderPassCreateFlags
++//bitfield VkRenderPassCreateFlagBits {
++//}
++
++/// Framebuffer creation flags
++type VkFlags VkFramebufferCreateFlags
++//bitfield VkFramebufferCreateFlagBits {
++//}
++
+ @extension("VK_EXT_KHR_swapchain")
+ type VkFlags VkSurfaceTransformFlagsKHR
+ @extension("VK_EXT_KHR_swapchain")
+@@ -1055,6 +1164,16 @@ bitfield VkSurfaceTransformFlagBitsKHR {
+ VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
+ }
+
++@extension("VK_EXT_KHR_swapchain")
++type VkFlags VkCompositeAlphaFlagsKHR
++@extension("VK_EXT_KHR_swapchain")
++bitfield VkCompositeAlphaFlagBitsKHR {
++ VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
++ VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
++ VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
++ VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
++}
++
+ @extension("VK_EXT_KHR_display")
+ type VkFlags VkDisplayPlaneAlphaFlagsKHR
+ @extension("VK_EXT_KHR_display")
+@@ -1175,6 +1294,7 @@ class VkAllocCallbacks {
+ class VkDeviceQueueCreateInfo {
+ VkStructureType sStype /// Should be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkDeviceQueueCreateFlags flags
+ u32 queueFamilyIndex
+ u32 queuePriorityCount
+ const f32* pQueuePriorities
+@@ -1183,6 +1303,7 @@ class VkDeviceQueueCreateInfo {
+ class VkDeviceCreateInfo {
+ VkStructureType sType /// Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkDeviceCreateFlags flags
+ u32 requestedQueueRecordCount
+ const VkDeviceQueueCreateInfo* pRequestedQueues
+ u32 enabledLayerNameCount
+@@ -1195,6 +1316,7 @@ class VkDeviceCreateInfo {
+ class VkInstanceCreateInfo {
+ VkStructureType sType /// Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkInstanceCreateFlags flags
+ const VkApplicationInfo* pAppInfo
+ u32 enabledLayerNameCount
+ const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled
+@@ -1314,9 +1436,9 @@ class VkCopyDescriptorSet {
+ class VkBufferCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
+ const void* pNext /// Pointer to next structure.
++ VkBufferCreateFlags flags /// Buffer creation flags
+ VkDeviceSize size /// Specified in bytes
+ VkBufferUsageFlags usage /// Buffer usage flags
+- VkBufferCreateFlags flags /// Buffer creation flags
+ VkSharingMode sharingMode
+ u32 queueFamilyIndexCount
+ const u32* pQueueFamilyIndices
+@@ -1325,6 +1447,7 @@ class VkBufferCreateInfo {
+ class VkBufferViewCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
+ const void* pNext /// Pointer to next structure.
++ VkBufferViewCreateFlags flags
+ VkBuffer buffer
+ VkFormat format /// Optionally specifies format of elements
+ VkDeviceSize offset /// Specified in bytes
+@@ -1380,6 +1503,7 @@ class VkImageMemoryBarrier {
+ class VkImageCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
+ const void* pNext /// Pointer to next structure.
++ VkImageCreateFlags flags /// Image creation flags
+ VkImageType imageType
+ VkFormat format
+ VkExtent3D extent
+@@ -1388,7 +1512,6 @@ class VkImageCreateInfo {
+ u32 samples
+ VkImageTiling tiling
+ VkImageUsageFlags usage /// Image usage flags
+- VkImageCreateFlags flags /// Image creation flags
+ VkSharingMode sharingMode /// Cross-queue-family sharing mode
+ u32 queueFamilyIndexCount /// Number of queue families to share across
+ const u32* pQueueFamilyIndices /// Array of queue family indices to share across
+@@ -1405,12 +1528,12 @@ class VkSubresourceLayout {
+ class VkImageViewCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkImageViewCreateFlags flags
+ VkImage image
+ VkImageViewType viewType
+ VkFormat format
+ VkChannelMapping channels
+ VkImageSubresourceRange subresourceRange
+- VkImageViewCreateFlags flags
+ }
+
+ class VkBufferCopy {
+@@ -1419,7 +1542,7 @@ class VkBufferCopy {
+ VkDeviceSize copySize /// Specified in bytes
+ }
+
+-class VkSparseMemoryBindInfo {
++class VkSparseMemoryBind {
+ VkDeviceSize rangeOffset /// Specified in bytes
+ VkDeviceSize rangeSize /// Specified in bytes
+ VkDeviceSize memOffset /// Specified in bytes
+@@ -1427,7 +1550,7 @@ class VkSparseMemoryBindInfo {
+ VkSparseMemoryBindFlags flags
+ }
+
+-class VkSparseImageMemoryBindInfo {
++class VkSparseImageMemoryBind {
+ VkImageSubresource subresource
+ VkOffset3D offset
+ VkExtent3D extent
+@@ -1436,6 +1559,39 @@ class VkSparseImageMemoryBindInfo {
+ VkSparseMemoryBindFlags flags
+ }
+
++class VkSparseBufferMemoryBindInfo {
++ VkBuffer buffer
++ u32 bindCount
++ const VkSparseMemoryBind* pBinds
++}
++
++class VkSparseImageOpaqueMemoryBindInfo {
++ VkImage image
++ u32 bindCount
++ const VkSparseMemoryBind* pBinds
++}
++
++class VkSparseImageMemoryBindInfo {
++ VkImage image
++ u32 bindCount
++ const VkSparseMemoryBind* pBinds
++}
++
++class VkBindSparseInfo {
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BIND_SPARSE_INFO
++ const void* pNext
++ u32 waitSemaphoreCount
++ const VkSemaphore* pWaitSemaphores
++ u32 numBufferBinds
++ const VkSparseBufferMemoryBindInfo* pBufferBinds
++ u32 numImageOpaqueBinds
++ const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds
++ u32 numImageBinds
++ const VkSparseImageMemoryBindInfo* pImageBinds
++ u32 signalSemaphoreCount
++ const VkSemaphore* pSignalSemaphores
++}
++
+ class VkImageSubresourceCopy {
+ VkImageAspectFlags aspect
+ u32 mipLevel
+@@ -1480,17 +1636,17 @@ class VkImageResolve {
+ class VkShaderModuleCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkShaderModuleCreateFlags flags /// Reserved
+ platform.size_t codeSize /// Specified in bytes
+ const u32* pCode /// Binary code of size codeSize
+- VkShaderModuleCreateFlags flags /// Reserved
+ }
+
+ class VkShaderCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkShaderCreateFlags flags /// Reserved
+ VkShaderModule module /// Module containing entry point
+ const char* pName /// Null-terminated entry point name
+- VkShaderCreateFlags flags /// Reserved
+ VkShaderStageFlagBits stage
+ }
+
+@@ -1504,6 +1660,7 @@ class VkDescriptorSetLayoutBinding {
+ class VkDescriptorSetLayoutCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkDescriptorSetLayoutCreateFlags flags
+ u32 bindingCount /// Number of bindings in the descriptor set layout
+ const VkDescriptorSetLayoutBinding* pBindings /// Array of descriptor set layout bindings
+ }
+@@ -1546,6 +1703,7 @@ class VkSpecializationInfo {
+ class VkPipelineShaderStageCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineShaderStageCreateFlags flags
+ VkShader shader
+ const VkSpecializationInfo* pSpecializationInfo
+ }
+@@ -1553,8 +1711,8 @@ class VkPipelineShaderStageCreateInfo {
+ class VkComputePipelineCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- VkPipelineShaderStageCreateInfo stage
+ VkPipelineCreateFlags flags /// Pipeline creation flags
++ VkPipelineShaderStageCreateInfo stage
+ VkPipelineLayout layout /// Interface layout of the pipeline
+ VkPipeline basePipelineHandle /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
+ s32 basePipelineIndex /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
+@@ -1576,6 +1734,7 @@ class VkVertexInputAttributeDescription {
+ class VkPipelineVertexInputStateCreateInfo {
+ VkStructureType sType /// Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineVertexInputStateCreateFlags flags
+ u32 vertexBindingDescriptionCount /// number of bindings
+ const VkVertexInputBindingDescription* pVertexBindingDescriptions
+ u32 vertexAttributeDescriptionCount /// number of attributes
+@@ -1585,6 +1744,7 @@ class VkPipelineVertexInputStateCreateInfo {
+ class VkPipelineInputAssemblyStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineInputAssemblyStateCreateFlags flags
+ VkPrimitiveTopology topology
+ VkBool32 primitiveRestartEnable
+ }
+@@ -1592,12 +1752,14 @@ class VkPipelineInputAssemblyStateCreateInfo {
+ class VkPipelineTessellationStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineTessellationStateCreateFlags flags
+ u32 patchControlPoints
+ }
+
+ class VkPipelineViewportStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineViewportStateCreateFlags flags
+ u32 viewportCount
+ const VkViewport* pViewports
+ u32 scissorCount
+@@ -1607,6 +1769,7 @@ class VkPipelineViewportStateCreateInfo {
+ class VkPipelineRasterStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineRasterStateCreateFlags flags
+ VkBool32 depthClampEnable
+ VkBool32 rasterizerDiscardEnable
+ VkFillMode fillMode /// optional (GL45)
+@@ -1622,6 +1785,7 @@ class VkPipelineRasterStateCreateInfo {
+ class VkPipelineMultisampleStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineMultisampleStateCreateFlags flags
+ u32 rasterSamples /// Number of samples used for rasterization
+ VkBool32 sampleShadingEnable /// optional (GL45)
+ f32 minSampleShading /// optional (GL45)
+@@ -1644,6 +1808,7 @@ class VkPipelineColorBlendAttachmentState {
+ class VkPipelineColorBlendStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineColorBlendStateCreateFlags flags
+ VkBool32 logicOpEnable
+ VkLogicOp logicOp
+ u32 attachmentCount /// # of pAttachments
+@@ -1664,6 +1829,7 @@ class VkStencilOpState {
+ class VkPipelineDepthStencilStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineDepthStencilStateCreateFlags flags
+ VkBool32 depthTestEnable
+ VkBool32 depthWriteEnable
+ VkCompareOp depthCompareOp
+@@ -1678,15 +1844,17 @@ class VkPipelineDepthStencilStateCreateInfo {
+ class VkPipelineDynamicStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineDynamicStateCreateFlags flags
+ u32 dynamicStateCount
+ const VkDynamicState* pDynamicStates
+ }
+
+ class VkGraphicsPipelineCreateInfo {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
+- const void* pNext /// Pointer to next structure
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
++ const void* pNext /// Pointer to next structure
++ VkPipelineCreateFlags flags /// Pipeline creation flags
+ u32 stageCount
+- const VkPipelineShaderStageCreateInfo* pStages /// One entry for each active shader stage
++ const VkPipelineShaderStageCreateInfo* pStages /// One entry for each active shader stage
+ const VkPipelineVertexInputStateCreateInfo* pVertexInputState
+ const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState
+ const VkPipelineTessellationStateCreateInfo* pTessellationState
+@@ -1696,17 +1864,17 @@ class VkGraphicsPipelineCreateInfo {
+ const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState
+ const VkPipelineColorBlendStateCreateInfo* pColorBlendState
+ const VkPipelineDynamicStateCreateInfo* pDynamicState
+- VkPipelineCreateFlags flags /// Pipeline creation flags
+- VkPipelineLayout layout /// Interface layout of the pipeline
++ VkPipelineLayout layout /// Interface layout of the pipeline
+ VkRenderPass renderPass
+ u32 subpass
+- VkPipeline basePipelineHandle /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
+- s32 basePipelineIndex /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
++ VkPipeline basePipelineHandle /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
++ s32 basePipelineIndex /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
+ }
+
+ class VkPipelineCacheCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineCacheCreateFlags flags
+ platform.size_t initialSize /// Size of initial data to populate cache, in bytes
+ const void* initialData /// Initial data to populate cache
+ platform.size_t maxSize /// Maximum size cache can grow to, in bytes. If zero, then the cache may grow without bound.
+@@ -1721,6 +1889,7 @@ class VkPushConstantRange {
+ class VkPipelineLayoutCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkPipelineLayoutCreateFlags flags
+ u32 setLayoutCount /// Number of descriptor sets interfaced by the pipeline
+ const VkDescriptorSetLayout* pSetLayouts /// Array of <setCount> number of descriptor set layout objects defining the layout of the
+ u32 pushConstantRangeCount /// Number of push-constant ranges used by the pipeline
+@@ -1730,6 +1899,7 @@ class VkPipelineLayoutCreateInfo {
+ class VkSamplerCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkSamplerCreateFlags flags
+ VkFilter magFilter /// Filter mode for magnification
+ VkFilter minFilter /// Filter mode for minifiation
+ VkSamplerMipmapMode mipmapMode /// Mipmap selection mode
+@@ -1749,8 +1919,8 @@ class VkSamplerCreateInfo {
+ class VkCmdPoolCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- u32 queueFamilyIndex
+ VkCmdPoolCreateFlags flags /// Command pool creation flags
++ u32 queueFamilyIndex
+ }
+
+ class VkCmdBufferAllocInfo {
+@@ -1809,6 +1979,7 @@ class VkClearAttachment {
+ class VkAttachmentDescription {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION
+ const void* pNext /// Pointer to next structure
++ VkAttachmentDescriptionFlags flags
+ VkFormat format
+ u32 samples
+ VkAttachmentLoadOp loadOp /// Load op for color or depth data
+@@ -1817,7 +1988,6 @@ class VkAttachmentDescription {
+ VkAttachmentStoreOp stencilStoreOp /// Store op for stencil data
+ VkImageLayout initialLayout
+ VkImageLayout finalLayout
+- VkAttachmentDescriptionFlags flags
+ }
+
+ class VkAttachmentReference {
+@@ -1828,8 +1998,8 @@ class VkAttachmentReference {
+ class VkSubpassDescription {
+ VkStructureType sType /// Must be VK_STRUCTURE_SUBPASS_DESCRIPTION
+ const void* pNext /// Pointer to next structure
+- VkPipelineBindPoint pipelineBindPoint /// Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now
+ VkSubpassDescriptionFlags flags
++ VkPipelineBindPoint pipelineBindPoint /// Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now
+ u32 inputAttachmentCount
+ const VkAttachmentReference* pInputAttachments
+ u32 colorAttachmentCount
+@@ -1855,6 +2025,7 @@ class VkSubpassDependency {
+ class VkRenderPassCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkRenderPassCreateFlags flags
+ u32 attachmentCount
+ const VkAttachmentDescription* pAttachments
+ u32 subpassCount
+@@ -2071,6 +2242,7 @@ class VkSemaphoreCreateInfo {
+ class VkQueryPoolCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkQueryPoolCreateFlags flags
+ VkQueryType queryType
+ u32 slots
+ VkQueryPipelineStatisticFlags pipelineStatistics /// Optional
+@@ -2079,6 +2251,7 @@ class VkQueryPoolCreateInfo {
+ class VkFramebufferCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
+ const void* pNext /// Pointer to next structure
++ VkFramebufferCreateFlags flags
+ VkRenderPass renderPass
+ u32 attachmentCount
+ const VkImageView* pAttachments
+@@ -2117,6 +2290,7 @@ class VkSurfacePropertiesKHR {
+ VkExtent2D maxImageExtent
+ VkSurfaceTransformFlagsKHR supportedTransforms
+ VkSurfaceTransformKHR currentTransform
++ VkCompositeAlphaFlagsKHR supportedCompositeAlpha
+ u32 maxImageArraySize
+ VkImageUsageFlags supportedUsageFlags
+ }
+@@ -2138,6 +2312,7 @@ class VkSwapchainCreateInfoKHR {
+ VkExtent2D imageExtent
+ VkImageUsageFlags imageUsageFlags
+ VkSurfaceTransformKHR preTransform
++ VkCompositeAlphaFlagBitsKHR compositeAlpha
+ u32 imageArraySize
+ VkSharingMode sharingMode
+ u32 queueFamilyIndexCount
+@@ -2163,41 +2338,37 @@ class VkDisplayPropertiesKHR {
+ VkExtent2D physicalDimensions
+ VkExtent2D physicalResolution
+ VkSurfaceTransformFlagsKHR supportedTransforms
+- u32 planeCount
+ VkBool32 planeReorderPossible
++ VkBool32 persistentContent
+ }
+
+ @extension("VK_EXT_KHR_display")
+-class VkDisplayTimingKHR {
+- u32 pixelClock
++class VkDisplayModeParametersKHR {
+ VkExtent2D visibleRegion
+- VkExtent2D totalRegion
+- VkExtent2D physicalDimensions
+- u32 hSyncStart
+- u32 hSyncEnd
+- u32 vSyncStart
+- u32 vSyncEnd
+- VkBool32 interlaced
+- VkBool32 doublescan
+- VkBool32 hSyncPos
+- VkBool32 vSyncPos
++ u32 refreshRate
+ }
+
+ @extension("VK_EXT_KHR_display")
+ class VkDisplayModePropertiesKHR {
+ VkDisplayModeKHR displayMode
+- VkDisplayTimingKHR timing
++ VkDisplayModeParametersKHR parameters
+ }
+
+ @extension("VK_EXT_KHR_display")
+ class VkDisplayModeCreateInfoKHR {
+ VkStructureType sType
+ const void* pNext
+- VkDisplayTimingKHR timing
++ VkDisplayModeParametersKHR parameters
+ }
+
+ @extension("VK_EXT_KHR_display")
+ class VkDisplayPlanePropertiesKHR {
++ VkDisplayKHR currentDisplay
++ u32 currentStackIndex
++}
++
++@extension("VK_EXT_KHR_display")
++class VkDisplayPlaneCapabilitiesKHR {
+ VkDisplayPlaneAlphaFlagsKHR supportedAlpha
+ VkOffset2D minSrcPosition
+ VkOffset2D maxSrcPosition
+@@ -2210,7 +2381,7 @@ class VkDisplayPlanePropertiesKHR {
+ }
+
+ @extension("VK_EXT_KHR_display")
+-class VkSurfaceDescriptionDisplayPlaneKHR {
++class VkDisplaySurfaceCreateInfoKHR {
+ VkStructureType sType
+ const void* pNext
+ VkDisplayModeKHR displayMode
+@@ -2235,6 +2406,7 @@ class VkDisplayPresentInfoKHR {
+ const void* pNext
+ VkRect2D srcRect
+ VkRect2D dstRect
++ VkBool32 persistent
+ }
+
+
+@@ -2801,37 +2973,12 @@ cmd void vkGetPhysicalDeviceSparseImageFormatProperties(
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+ }
+
+-cmd VkResult vkQueueBindSparseBufferMemory(
++cmd VkResult vkQueueBindSparse(
+ VkQueue queue,
+- VkBuffer buffer,
+ u32 bindInfoCount,
+- const VkSparseMemoryBindInfo* pBindInfo) {
+- queueObject := GetQueue(queue)
+- bufferObject := GetBuffer(buffer)
+- assert(bufferObject.device == queueObject.device)
+-
+- return ?
+-}
+-
+-cmd VkResult vkQueueBindSparseImageOpaqueMemory(
+- VkQueue queue,
+- VkImage image,
+- u32 bindInfoCount,
+- const VkSparseMemoryBindInfo* pBindInfo) {
+- queueObject := GetQueue(queue)
+- imageObject := GetImage(image)
+- assert(imageObject.device == queueObject.device)
+-
+- return ?
+-}
+-
+-cmd VkResult vkQueueBindSparseImageMemory(
+- VkQueue queue,
+- VkImage image,
+- u32 bindInfoCount,
+- const VkSparseImageMemoryBindInfo* pBindInfo) {
++ const VkBindSparseInfo* pBindInfo,
++ VkFence fence) {
+ queueObject := GetQueue(queue)
+- imageObject := GetImage(image)
+
+ return ?
+ }
+@@ -4490,7 +4637,7 @@ cmd void vkDestroySurfaceKHR(
+ }
+
+ @extension("VK_EXT_KHR_surface")
+-cmd VkBool32 vkGetPhysicalDeviceSurfaceSupportKHR(
++cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ u32 queueFamilyIndex,
+ VkSurfaceKHR surface) {
+@@ -4640,6 +4787,24 @@ cmd VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
+ }
+
+ @extension("VK_EXT_KHR_display")
++cmd VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
++ VkPhysicalDevice physicalDevice,
++ u32* pPropertyCount,
++ VkDisplayPlanePropertiesKHR* pProperties) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
++ return ?
++}
++
++@extension("VK_EXT_KHR_display")
++cmd VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
++ VkPhysicalDevice physicalDevice,
++ u32* pPropertyCount,
++ VkDisplayKHR* pProperties) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
++ return ?
++}
++
++@extension("VK_EXT_KHR_display")
+ cmd VkResult vkGetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+@@ -4660,38 +4825,63 @@ cmd VkResult vkCreateDisplayModeKHR(
+ }
+
+ @extension("VK_EXT_KHR_display")
+-cmd VkResult vkGetDisplayPlanePropertiesKHR(
++cmd VkResult vkGetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+- VkDisplayKHR display,
+- VkDisplayModeKHR mode,
++ VkDisplayModeCreateInfoKHR mode,
+ u32 planeIndex,
+- VkDisplayPlanePropertiesKHR* pProperties) {
++ VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_x11_surface")
+-cmd VkResult vkCreateX11SurfaceKHR(
++@extension("VK_EXT_KHR_display")
++cmd VkResult vkCreateDisplayPlaneSurfaceKHR(
++ VkInstance instance,
++ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
++ VkSurfaceKHR* pSurface) {
++ return ?
++}
++
++@extension("VK_EXT_KHR_xlib_surface")
++cmd VkResult vkCreateXlibSurfaceKHR(
+ VkInstance instance,
+ platform.Display* dpy,
+- platform.Window root,
+ platform.Window window,
+ VkSurfaceKHR* pSurface) {
+ instanceObject := GetInstance(instance)
+ return ?
+ }
+
++@extension("VK_EXT_KHR_xlib_surface")
++cmd VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ u32 queueFamilyIndex,
++ platform.Display* dpy,
++ platform.VisualID visualId) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
++ return ?
++}
++
+ @extension("VK_EXT_KHR_xcb_surface")
+ cmd VkResult vkCreateXCBSurfaceKHR(
+ VkInstance instance,
+ platform.xcb_connection_t* connection,
+- platform.xcb_window_t root,
+ platform.xcb_window_t window,
+ VkSurfaceKHR* pSurface) {
+ instanceObject := GetInstance(instance)
+ return ?
+ }
+
++@extension("VK_EXT_KHR_xlib_surface")
++cmd VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ u32 queueFamilyIndex,
++ platform.xcb_connection_t* connection,
++ platform.xcb_visualid_t visual_id) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
++ return ?
++}
++
+ @extension("VK_EXT_KHR_wayland_surface")
+ cmd VkResult vkCreateWaylandSurfaceKHR(
+ VkInstance instance,
+@@ -4702,6 +4892,15 @@ cmd VkResult vkCreateWaylandSurfaceKHR(
+ return ?
+ }
+
++@extension("VK_EXT_KHR_wayland_surface")
++cmd VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ u32 queueFamilyIndex,
++ platform.wl_display* display) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
++ return ?
++}
++
+ @extension("VK_EXT_KHR_mir_surface")
+ cmd VkResult vkCreateMirSurfaceKHR(
+ VkInstance instance,
+@@ -4712,6 +4911,15 @@ cmd VkResult vkCreateMirSurfaceKHR(
+ return ?
+ }
+
++@extension("VK_EXT_KHR_mir_surface")
++cmd VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ u32 queueFamilyIndex,
++ platform.MirConnection* connection) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
++ return ?
++}
++
+ @extension("VK_EXT_KHR_android_surface")
+ cmd VkResult vkCreateAndroidSurfaceKHR(
+ VkInstance instance,
+@@ -4731,6 +4939,14 @@ cmd VkResult vkCreateWin32SurfaceKHR(
+ return ?
+ }
+
++@extension("VK_EXT_KHR_win32_surface")
++cmd VkResult vkGetPhysicalDeviceWin32PresentationSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ u32 queueFamilyIndex) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
++ return ?
++}
++
+
+ ////////////////
+ // Validation //
+diff --git a/vulkan/include/vulkan/vk_platform.h b/vulkan/include/vulkan/vk_platform.h
+index 14dc553..8d51524 100644
+--- a/vulkan/include/vulkan/vk_platform.h
++++ b/vulkan/include/vulkan/vk_platform.h
+@@ -91,7 +91,7 @@ extern "C"
+ #include <windows.h>
+ #endif
+
+-#ifdef VK_USE_PLATFORM_X11_KHR
++#ifdef VK_USE_PLATFORM_XLIB_KHR
+ #include <X11/Xlib.h>
+ #endif
+
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index dc977e5..dcc5301 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -1,5 +1,5 @@
+-#ifndef __vulkan_h_
+-#define __vulkan_h_ 1
++#ifndef __vulkanext_h_
++#define __vulkanext_h_ 1
+
+ #ifdef __cplusplus
+ extern "C" {
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 189, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 190, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -59,8 +59,8 @@ extern "C" {
+
+
+
+-typedef uint32_t VkBool32;
+ typedef uint32_t VkFlags;
++typedef uint32_t VkBool32;
+ typedef uint64_t VkDeviceSize;
+ typedef uint32_t VkSampleMask;
+
+@@ -182,9 +182,10 @@ typedef enum {
+ VK_STRUCTURE_TYPE_SUBMIT_INFO = 48,
+ VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 49,
+ VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 50,
++ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 51,
+ VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+- VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO,
+- VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
++ VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,
++ VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_BIND_SPARSE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+ VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkStructureType;
+
+@@ -763,6 +764,7 @@ typedef enum {
+ VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
+ } VkRenderPassContents;
+
++typedef VkFlags VkInstanceCreateFlags;
+
+ typedef enum {
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
+@@ -833,6 +835,8 @@ typedef enum {
+ VK_MEMORY_HEAP_HOST_LOCAL_BIT = 0x00000001,
+ } VkMemoryHeapFlagBits;
+ typedef VkFlags VkMemoryHeapFlags;
++typedef VkFlags VkDeviceCreateFlags;
++typedef VkFlags VkDeviceQueueCreateFlags;
+ typedef VkFlags VkMemoryMapFlags;
+
+ typedef enum {
+@@ -860,6 +864,7 @@ typedef enum {
+ typedef VkFlags VkFenceCreateFlags;
+ typedef VkFlags VkSemaphoreCreateFlags;
+ typedef VkFlags VkEventCreateFlags;
++typedef VkFlags VkQueryPoolCreateFlags;
+
+ typedef enum {
+ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
+@@ -886,6 +891,13 @@ typedef enum {
+ typedef VkFlags VkQueryResultFlags;
+
+ typedef enum {
++ VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
++ VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
++ VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
++} VkBufferCreateFlagBits;
++typedef VkFlags VkBufferCreateFlags;
++
++typedef enum {
+ VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
+ VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
+ VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
+@@ -897,20 +909,14 @@ typedef enum {
+ VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
+ } VkBufferUsageFlagBits;
+ typedef VkFlags VkBufferUsageFlags;
+-
+-typedef enum {
+- VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
+- VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
+- VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
+-} VkBufferCreateFlagBits;
+-typedef VkFlags VkBufferCreateFlags;
+-typedef VkFlags VkImageAspectFlags;
++typedef VkFlags VkBufferViewCreateFlags;
+
+ typedef enum {
+ VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
+ VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
+ } VkImageViewCreateFlagBits;
+ typedef VkFlags VkImageViewCreateFlags;
++typedef VkFlags VkImageAspectFlags;
+ typedef VkFlags VkShaderModuleCreateFlags;
+ typedef VkFlags VkShaderCreateFlags;
+
+@@ -923,6 +929,23 @@ typedef enum {
+ VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
+ VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+ } VkShaderStageFlagBits;
++typedef VkFlags VkPipelineCacheCreateFlags;
++
++typedef enum {
++ VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
++ VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
++ VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
++} VkPipelineCreateFlagBits;
++typedef VkFlags VkPipelineCreateFlags;
++typedef VkFlags VkPipelineShaderStageCreateFlags;
++typedef VkFlags VkPipelineVertexInputStateCreateFlags;
++typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
++typedef VkFlags VkPipelineTesselationStateCreateFlags;
++typedef VkFlags VkPipelineViewportStateCreateFlags;
++typedef VkFlags VkPipelineRasterStateCreateFlags;
++typedef VkFlags VkPipelineMultisampleStateCreateFlags;
++typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
++typedef VkFlags VkPipelineColorBlendStateCreateFlags;
+
+ typedef enum {
+ VK_CHANNEL_R_BIT = 0x00000001,
+@@ -931,20 +954,19 @@ typedef enum {
+ VK_CHANNEL_A_BIT = 0x00000008,
+ } VkChannelFlagBits;
+ typedef VkFlags VkChannelFlags;
+-
+-typedef enum {
+- VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
+- VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
+- VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
+-} VkPipelineCreateFlagBits;
+-typedef VkFlags VkPipelineCreateFlags;
++typedef VkFlags VkPipelineDynamicStateCreateFlags;
++typedef VkFlags VkPipelineLayoutCreateFlags;
+ typedef VkFlags VkShaderStageFlags;
++typedef VkFlags VkSamplerCreateFlags;
++typedef VkFlags VkDescriptorSetLayoutCreateFlags;
+
+ typedef enum {
+ VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
+ } VkDescriptorPoolCreateFlagBits;
+ typedef VkFlags VkDescriptorPoolCreateFlags;
+ typedef VkFlags VkDescriptorPoolResetFlags;
++typedef VkFlags VkFramebufferCreateFlags;
++typedef VkFlags VkRenderPassCreateFlags;
+
+ typedef enum {
+ VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
+@@ -1074,6 +1096,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkInstanceCreateFlags flags;
+ const VkApplicationInfo* pAppInfo;
+ uint32_t enabledLayerNameCount;
+ const char*const* ppEnabledLayerNames;
+@@ -1314,6 +1337,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkDeviceQueueCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ uint32_t queuePriorityCount;
+ const float* pQueuePriorities;
+@@ -1322,6 +1346,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkDeviceCreateFlags flags;
+ uint32_t requestedQueueCount;
+ const VkDeviceQueueCreateInfo* pRequestedQueues;
+ uint32_t enabledLayerNameCount;
+@@ -1395,7 +1420,19 @@ typedef struct {
+ VkDeviceSize memOffset;
+ VkDeviceMemory mem;
+ VkSparseMemoryBindFlags flags;
+-} VkSparseMemoryBindInfo;
++} VkSparseMemoryBind;
++
++typedef struct {
++ VkBuffer buffer;
++ uint32_t bindCount;
++ const VkSparseMemoryBind* pBinds;
++} VkSparseBufferMemoryBindInfo;
++
++typedef struct {
++ VkImage image;
++ uint32_t bindCount;
++ const VkSparseMemoryBind* pBinds;
++} VkSparseImageOpaqueMemoryBindInfo;
+
+ typedef struct {
+ VkImageAspectFlagBits aspect;
+@@ -1416,11 +1453,32 @@ typedef struct {
+ VkDeviceSize memOffset;
+ VkDeviceMemory mem;
+ VkSparseMemoryBindFlags flags;
++} VkSparseImageMemoryBind;
++
++typedef struct {
++ VkImage image;
++ uint32_t bindCount;
++ const VkSparseImageMemoryBind* pBinds;
+ } VkSparseImageMemoryBindInfo;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ uint32_t waitSemaphoreCount;
++ const VkSemaphore* pWaitSemaphores;
++ uint32_t bufferBindCount;
++ const VkSparseBufferMemoryBindInfo* pBufferBinds;
++ uint32_t imageOpaqueBindCount;
++ const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
++ uint32_t imageBindCount;
++ const VkSparseImageMemoryBindInfo* pImageBinds;
++ uint32_t signalSemaphoreCount;
++ const VkSemaphore* pSignalSemaphores;
++} VkBindSparseInfo;
++
++typedef struct {
++ VkStructureType sType;
++ const void* pNext;
+ VkFenceCreateFlags flags;
+ } VkFenceCreateInfo;
+
+@@ -1439,6 +1497,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkQueryPoolCreateFlags flags;
+ VkQueryType queryType;
+ uint32_t slots;
+ VkQueryPipelineStatisticFlags pipelineStatistics;
+@@ -1447,9 +1506,9 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkBufferCreateFlags flags;
+ VkDeviceSize size;
+ VkBufferUsageFlags usage;
+- VkBufferCreateFlags flags;
+ VkSharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+@@ -1458,6 +1517,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkBufferViewCreateFlags flags;
+ VkBuffer buffer;
+ VkFormat format;
+ VkDeviceSize offset;
+@@ -1467,6 +1527,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkImageCreateFlags flags;
+ VkImageType imageType;
+ VkFormat format;
+ VkExtent3D extent;
+@@ -1475,7 +1536,6 @@ typedef struct {
+ uint32_t samples;
+ VkImageTiling tiling;
+ VkImageUsageFlags usage;
+- VkImageCreateFlags flags;
+ VkSharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
+@@ -1507,34 +1567,35 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkImageViewCreateFlags flags;
+ VkImage image;
+ VkImageViewType viewType;
+ VkFormat format;
+ VkChannelMapping channels;
+ VkImageSubresourceRange subresourceRange;
+- VkImageViewCreateFlags flags;
+ } VkImageViewCreateInfo;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkShaderModuleCreateFlags flags;
+ size_t codeSize;
+ const uint32_t* pCode;
+- VkShaderModuleCreateFlags flags;
+ } VkShaderModuleCreateInfo;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkShaderCreateFlags flags;
+ VkShaderModule module;
+ const char* pName;
+- VkShaderCreateFlags flags;
+ VkShaderStageFlagBits stage;
+ } VkShaderCreateInfo;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineCacheCreateFlags flags;
+ size_t initialSize;
+ const void* initialData;
+ size_t maxSize;
+@@ -1556,6 +1617,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineShaderStageCreateFlags flags;
+ VkShader shader;
+ const VkSpecializationInfo* pSpecializationInfo;
+ } VkPipelineShaderStageCreateInfo;
+@@ -1576,6 +1638,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineVertexInputStateCreateFlags flags;
+ uint32_t vertexBindingDescriptionCount;
+ const VkVertexInputBindingDescription* pVertexBindingDescriptions;
+ uint32_t vertexAttributeDescriptionCount;
+@@ -1585,6 +1648,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineInputAssemblyStateCreateFlags flags;
+ VkPrimitiveTopology topology;
+ VkBool32 primitiveRestartEnable;
+ } VkPipelineInputAssemblyStateCreateInfo;
+@@ -1592,6 +1656,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineTesselationStateCreateFlags flags;
+ uint32_t patchControlPoints;
+ } VkPipelineTessellationStateCreateInfo;
+
+@@ -1622,6 +1687,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineViewportStateCreateFlags flags;
+ uint32_t viewportCount;
+ const VkViewport* pViewports;
+ uint32_t scissorCount;
+@@ -1631,6 +1697,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineRasterStateCreateFlags flags;
+ VkBool32 depthClampEnable;
+ VkBool32 rasterizerDiscardEnable;
+ VkFillMode fillMode;
+@@ -1646,6 +1713,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineMultisampleStateCreateFlags flags;
+ uint32_t rasterSamples;
+ VkBool32 sampleShadingEnable;
+ float minSampleShading;
+@@ -1667,6 +1735,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineDepthStencilStateCreateFlags flags;
+ VkBool32 depthTestEnable;
+ VkBool32 depthWriteEnable;
+ VkCompareOp depthCompareOp;
+@@ -1692,6 +1761,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineColorBlendStateCreateFlags flags;
+ VkBool32 logicOpEnable;
+ VkLogicOp logicOp;
+ uint32_t attachmentCount;
+@@ -1702,6 +1772,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineDynamicStateCreateFlags flags;
+ uint32_t dynamicStateCount;
+ const VkDynamicState* pDynamicStates;
+ } VkPipelineDynamicStateCreateInfo;
+@@ -1709,6 +1780,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineCreateFlags flags;
+ uint32_t stageCount;
+ const VkPipelineShaderStageCreateInfo* pStages;
+ const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
+@@ -1720,7 +1792,6 @@ typedef struct {
+ const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
+ const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
+ const VkPipelineDynamicStateCreateInfo* pDynamicState;
+- VkPipelineCreateFlags flags;
+ VkPipelineLayout layout;
+ VkRenderPass renderPass;
+ uint32_t subpass;
+@@ -1731,8 +1802,8 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkPipelineShaderStageCreateInfo stage;
+ VkPipelineCreateFlags flags;
++ VkPipelineShaderStageCreateInfo stage;
+ VkPipelineLayout layout;
+ VkPipeline basePipelineHandle;
+ int32_t basePipelineIndex;
+@@ -1747,6 +1818,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkPipelineLayoutCreateFlags flags;
+ uint32_t setLayoutCount;
+ const VkDescriptorSetLayout* pSetLayouts;
+ uint32_t pushConstantRangeCount;
+@@ -1756,6 +1828,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkSamplerCreateFlags flags;
+ VkFilter magFilter;
+ VkFilter minFilter;
+ VkSamplerMipmapMode mipmapMode;
+@@ -1782,6 +1855,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkDescriptorSetLayoutCreateFlags flags;
+ uint32_t bindingCount;
+ const VkDescriptorSetLayoutBinding* pBindings;
+ } VkDescriptorSetLayoutCreateInfo;
+@@ -1848,6 +1922,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkFramebufferCreateFlags flags;
+ VkRenderPass renderPass;
+ uint32_t attachmentCount;
+ const VkImageView* pAttachments;
+@@ -1859,6 +1934,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkAttachmentDescriptionFlags flags;
+ VkFormat format;
+ uint32_t samples;
+ VkAttachmentLoadOp loadOp;
+@@ -1867,7 +1943,6 @@ typedef struct {
+ VkAttachmentStoreOp stencilStoreOp;
+ VkImageLayout initialLayout;
+ VkImageLayout finalLayout;
+- VkAttachmentDescriptionFlags flags;
+ } VkAttachmentDescription;
+
+ typedef struct {
+@@ -1878,8 +1953,8 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkPipelineBindPoint pipelineBindPoint;
+ VkSubpassDescriptionFlags flags;
++ VkPipelineBindPoint pipelineBindPoint;
+ uint32_t inputAttachmentCount;
+ const VkAttachmentReference* pInputAttachments;
+ uint32_t colorAttachmentCount;
+@@ -1905,6 +1980,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ VkRenderPassCreateFlags flags;
+ uint32_t attachmentCount;
+ const VkAttachmentDescription* pAttachments;
+ uint32_t subpassCount;
+@@ -1916,8 +1992,8 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- uint32_t queueFamilyIndex;
+ VkCmdPoolCreateFlags flags;
++ uint32_t queueFamilyIndex;
+ } VkCmdPoolCreateInfo;
+
+ typedef struct {
+@@ -2110,9 +2186,7 @@ typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffe
+ typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+ typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
+-typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo);
+-typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo);
+-typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseImageMemoryBindInfo* pBindInfo);
++typedef VkResult (VKAPI *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
+ typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence);
+ typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
+@@ -2396,23 +2470,11 @@ void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties);
+
+-VkResult VKAPI vkQueueBindSparseBufferMemory(
++VkResult VKAPI vkQueueBindSparse(
+ VkQueue queue,
+- VkBuffer buffer,
+ uint32_t bindInfoCount,
+- const VkSparseMemoryBindInfo* pBindInfo);
+-
+-VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(
+- VkQueue queue,
+- VkImage image,
+- uint32_t bindInfoCount,
+- const VkSparseMemoryBindInfo* pBindInfo);
+-
+-VkResult VKAPI vkQueueBindSparseImageMemory(
+- VkQueue queue,
+- VkImage image,
+- uint32_t bindInfoCount,
+- const VkSparseImageMemoryBindInfo* pBindInfo);
++ const VkBindSparseInfo* pBindInfo,
++ VkFence fence);
+
+ VkResult VKAPI vkCreateFence(
+ VkDevice device,
+@@ -3033,19 +3095,20 @@ void VKAPI vkCmdExecuteCommands(
+ #define vk_ext_khr_surface 1
+ VK_DEFINE_NONDISP_HANDLE(VkSurfaceKHR)
+
+-#define VK_EXT_KHR_SURFACE_REVISION 19
++#define VK_EXT_KHR_SURFACE_REVISION 20
+ #define VK_EXT_KHR_SURFACE_EXTENSION_NUMBER 1
+ #define VK_EXT_KHR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_surface"
++#define VK_ERROR_SURFACE_LOST_KHR ((VkResult)(int)0xc0000400)
+
+ typedef void (VKAPI *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface);
+-typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface);
++typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface);
+
+ #ifdef VK_PROTOTYPES
+ void VKAPI vkDestroySurfaceKHR(
+ VkInstance instance,
+ VkSurfaceKHR surface);
+
+-VkBool32 VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
++VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface);
+@@ -3054,7 +3117,7 @@ VkBool32 VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
+ #define vk_ext_khr_swapchain 1
+ VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR)
+
+-#define VK_EXT_KHR_SWAPCHAIN_REVISION 59
++#define VK_EXT_KHR_SWAPCHAIN_REVISION 62
+ #define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+ #define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
+ #define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
+@@ -3113,6 +3176,14 @@ typedef enum {
+ } VkSurfaceTransformFlagBitsKHR;
+ typedef VkFlags VkSurfaceTransformFlagsKHR;
+
++typedef enum {
++ VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
++ VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
++ VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
++ VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
++} VkCompositeAlphaFlagBitsKHR;
++typedef VkFlags VkCompositeAlphaFlagsKHR;
++
+ typedef struct {
+ uint32_t minImageCount;
+ uint32_t maxImageCount;
+@@ -3121,6 +3192,7 @@ typedef struct {
+ VkExtent2D maxImageExtent;
+ VkSurfaceTransformFlagsKHR supportedTransforms;
+ VkSurfaceTransformKHR currentTransform;
++ VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
+ uint32_t maxImageArraySize;
+ VkImageUsageFlags supportedUsageFlags;
+ } VkSurfacePropertiesKHR;
+@@ -3140,6 +3212,7 @@ typedef struct {
+ VkExtent2D imageExtent;
+ VkImageUsageFlags imageUsageFlags;
+ VkSurfaceTransformKHR preTransform;
++ VkCompositeAlphaFlagBitsKHR compositeAlpha;
+ uint32_t imageArraySize;
+ VkSharingMode sharingMode;
+ uint32_t queueFamilyIndexCount;
+@@ -3217,11 +3290,11 @@ VkResult VKAPI vkQueuePresentKHR(
+ VK_DEFINE_NONDISP_HANDLE(VkDisplayKHR)
+ VK_DEFINE_NONDISP_HANDLE(VkDisplayModeKHR)
+
+-#define VK_EXT_KHR_DISPLAY_REVISION 16
++#define VK_EXT_KHR_DISPLAY_REVISION 17
+ #define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 3
+ #define VK_EXT_KHR_DISPLAY_EXTENSION_NAME "VK_EXT_KHR_display"
+ #define VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c00)
+-#define VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_DISPLAY_PLANE_KHR ((VkStructureType)(int)0xc0000c01)
++#define VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c01)
+
+
+ typedef enum {
+@@ -3237,37 +3310,32 @@ typedef struct {
+ VkExtent2D physicalDimensions;
+ VkExtent2D physicalResolution;
+ VkSurfaceTransformFlagsKHR supportedTransforms;
+- uint32_t planeCount;
+ VkBool32 planeReorderPossible;
++ VkBool32 persistentContent;
+ } VkDisplayPropertiesKHR;
+
+ typedef struct {
+- uint32_t pixelClock;
+ VkExtent2D visibleRegion;
+- VkExtent2D totalRegion;
+- VkExtent2D physicalDimensions;
+- uint32_t hSyncStart;
+- uint32_t hSyncEnd;
+- uint32_t vSyncStart;
+- uint32_t vSyncEnd;
+- VkBool32 interlaced;
+- VkBool32 doublescan;
+- VkBool32 hSyncPos;
+- VkBool32 vSyncPos;
+-} VkDisplayTimingKHR;
++ uint32_t refreshRate;
++} VkDisplayModeParametersKHR;
+
+ typedef struct {
+ VkDisplayModeKHR displayMode;
+- VkDisplayTimingKHR timing;
++ VkDisplayModeParametersKHR parameters;
+ } VkDisplayModePropertiesKHR;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkDisplayTimingKHR timing;
++ VkDisplayModeParametersKHR parameters;
+ } VkDisplayModeCreateInfoKHR;
+
+ typedef struct {
++ VkDisplayKHR currentDisplay;
++ uint32_t currentStackIndex;
++} VkDisplayPlanePropertiesKHR;
++
++typedef struct {
+ VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
+ VkOffset2D minSrcPosition;
+ VkOffset2D maxSrcPosition;
+@@ -3277,7 +3345,7 @@ typedef struct {
+ VkOffset2D maxDstPosition;
+ VkExtent2D minDstExtent;
+ VkExtent2D maxDstExtent;
+-} VkDisplayPlanePropertiesKHR;
++} VkDisplayPlaneCapabilitiesKHR;
+
+ typedef struct {
+ VkStructureType sType;
+@@ -3289,13 +3357,16 @@ typedef struct {
+ float globalAlpha;
+ VkDisplayPlaneAlphaFlagsKHR alphaMode;
+ VkExtent2D imageSize;
+-} VkSurfaceDescriptionDisplayPlaneKHR;
++} VkDisplaySurfaceCreateInfoKHR;
+
+
+ typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
++typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
++typedef VkResult (VKAPI *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayKHR* pProperties);
+ typedef VkResult (VKAPI *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
+ typedef VkResult (VKAPI *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, VkDisplayModeKHR* pMode);
+-typedef VkResult (VKAPI *PFN_vkGetDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlanePropertiesKHR* pProperties);
++typedef VkResult (VKAPI *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeCreateInfoKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
++typedef VkResult (VKAPI *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, VkSurfaceKHR* pSurface);
+
+ #ifdef VK_PROTOTYPES
+ VkResult VKAPI vkGetPhysicalDeviceDisplayPropertiesKHR(
+@@ -3303,6 +3374,16 @@ VkResult VKAPI vkGetPhysicalDeviceDisplayPropertiesKHR(
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties);
+
++VkResult VKAPI vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
++ VkPhysicalDevice physicalDevice,
++ uint32_t* pPropertyCount,
++ VkDisplayPlanePropertiesKHR* pProperties);
++
++VkResult VKAPI vkGetDisplayPlaneSupportedDisplaysKHR(
++ VkPhysicalDevice physicalDevice,
++ uint32_t* pPropertyCount,
++ VkDisplayKHR* pProperties);
++
+ VkResult VKAPI vkGetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+@@ -3315,16 +3396,20 @@ VkResult VKAPI vkCreateDisplayModeKHR(
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ VkDisplayModeKHR* pMode);
+
+-VkResult VKAPI vkGetDisplayPlanePropertiesKHR(
++VkResult VKAPI vkGetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+- VkDisplayKHR display,
+- VkDisplayModeKHR mode,
++ VkDisplayModeCreateInfoKHR mode,
+ uint32_t planeIndex,
+- VkDisplayPlanePropertiesKHR* pProperties);
++ VkDisplayPlaneCapabilitiesKHR* pCapabilities);
++
++VkResult VKAPI vkCreateDisplayPlaneSurfaceKHR(
++ VkInstance instance,
++ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
++ VkSurfaceKHR* pSurface);
+ #endif
+
+ #define vk_ext_khr_display_swapchain 1
+-#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_REVISION 4
++#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_REVISION 6
+ #define VK_EXT_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4
+ #define VK_EXT_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_display_swapchain"
+ #define VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0001000)
+@@ -3342,47 +3427,60 @@ typedef struct {
+ const void* pNext;
+ VkRect2D srcRect;
+ VkRect2D dstRect;
++ VkBool32 persistent;
+ } VkDisplayPresentInfoKHR;
+
+
+
+-#ifdef VK_USE_PLATFORM_X11_KHR
+-#define vk_ext_khr_x11_surface 1
++#ifdef VK_USE_PLATFORM_XLIB_KHR
++#define vk_ext_khr_xlib_surface 1
+ #include <X11/Xlib.h>
+
+-#define VK_EXT_KHR_X11_SURFACE_REVISION 1
+-#define VK_EXT_KHR_X11_SURFACE_EXTENSION_NUMBER 5
+-#define VK_EXT_KHR_X11_SURFACE_EXTENSION_NAME "VK_EXT_KHR_x11_surface"
++#define VK_EXT_KHR_XLIB_SURFACE_REVISION 3
++#define VK_EXT_KHR_XLIB_SURFACE_EXTENSION_NUMBER 5
++#define VK_EXT_KHR_XLIB_SURFACE_EXTENSION_NAME "vk_ext_khr_xlib_surface"
+
+-typedef VkResult (VKAPI *PFN_vkCreateX11SurfaceKHR)(VkInstance instance, Display* dpy, Window root, Window window, VkSurfaceKHR* pSurface);
++typedef VkResult (VKAPI *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, VkSurfaceKHR* pSurface);
++typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualId);
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkCreateX11SurfaceKHR(
++VkResult VKAPI vkCreateXlibSurfaceKHR(
+ VkInstance instance,
+ Display* dpy,
+- Window root,
+ Window window,
+ VkSurfaceKHR* pSurface);
++
++VkBool32 VKAPI vkGetPhysicalDeviceXlibPresentationSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ uint32_t queueFamilyIndex,
++ Display* dpy,
++ VisualID visualId);
+ #endif
+-#endif /* VK_USE_PLATFORM_X11_KHR */
++#endif /* VK_USE_PLATFORM_XLIB_KHR */
+
+ #ifdef VK_USE_PLATFORM_XCB_KHR
+ #define vk_ext_khr_xcb_surface 1
+ #include <xcb/xcb.h>
+
+-#define VK_EXT_KHR_XCB_SURFACE_REVISION 1
++#define VK_EXT_KHR_XCB_SURFACE_REVISION 3
+ #define VK_EXT_KHR_XCB_SURFACE_EXTENSION_NUMBER 6
+ #define VK_EXT_KHR_XCB_SURFACE_EXTENSION_NAME "VK_EXT_KHR_xcb_surface"
+
+-typedef VkResult (VKAPI *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, xcb_connection_t* connection, xcb_window_t root, xcb_window_t window, VkSurfaceKHR* pSurface);
++typedef VkResult (VKAPI *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, xcb_connection_t* connection, xcb_window_t window, VkSurfaceKHR* pSurface);
++typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
+
+ #ifdef VK_PROTOTYPES
+ VkResult VKAPI vkCreateXcbSurfaceKHR(
+ VkInstance instance,
+ xcb_connection_t* connection,
+- xcb_window_t root,
+ xcb_window_t window,
+ VkSurfaceKHR* pSurface);
++
++VkBool32 VKAPI vkGetPhysicalDeviceXcbPresentationSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ uint32_t queueFamilyIndex,
++ xcb_connection_t* connection,
++ xcb_visualid_t visual_id);
+ #endif
+ #endif /* VK_USE_PLATFORM_XCB_KHR */
+
+@@ -3390,11 +3488,12 @@ VkResult VKAPI vkCreateXcbSurfaceKHR(
+ #define vk_ext_khr_wayland_surface 1
+ #include <wayland-client.h>
+
+-#define VK_EXT_KHR_WAYLAND_SURFACE_REVISION 1
++#define VK_EXT_KHR_WAYLAND_SURFACE_REVISION 2
+ #define VK_EXT_KHR_WAYLAND_SURFACE_EXTENSION_NUMBER 7
+ #define VK_EXT_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_EXT_KHR_wayland_surface"
+
+ typedef VkResult (VKAPI *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, struct wl_display* display, struct wl_surface* surface, VkSurfaceKHR* pSurface);
++typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
+
+ #ifdef VK_PROTOTYPES
+ VkResult VKAPI vkCreateWaylandSurfaceKHR(
+@@ -3402,6 +3501,11 @@ VkResult VKAPI vkCreateWaylandSurfaceKHR(
+ struct wl_display* display,
+ struct wl_surface* surface,
+ VkSurfaceKHR* pSurface);
++
++VkBool32 VKAPI vkGetPhysicalDeviceWaylandPresentationSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ uint32_t queueFamilyIndex,
++ struct wl_display* display);
+ #endif
+ #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
+
+@@ -3409,11 +3513,12 @@ VkResult VKAPI vkCreateWaylandSurfaceKHR(
+ #define vk_ext_khr_mir_surface 1
+ #include <mir_toolkit/client_types.h>
+
+-#define VK_EXT_KHR_MIR_SURFACE_REVISION 1
++#define VK_EXT_KHR_MIR_SURFACE_REVISION 2
+ #define VK_EXT_KHR_MIR_SURFACE_EXTENSION_NUMBER 8
+ #define VK_EXT_KHR_MIR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_mir_surface"
+
+ typedef VkResult (VKAPI *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, MirConnection* connection, MirSurface* mirSurface, VkSurfaceKHR* pSurface);
++typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
+
+ #ifdef VK_PROTOTYPES
+ VkResult VKAPI vkCreateMirSurfaceKHR(
+@@ -3421,6 +3526,11 @@ VkResult VKAPI vkCreateMirSurfaceKHR(
+ MirConnection* connection,
+ MirSurface* mirSurface,
+ VkSurfaceKHR* pSurface);
++
++VkBool32 VKAPI vkGetPhysicalDeviceMirPresentationSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ uint32_t queueFamilyIndex,
++ MirConnection* connection);
+ #endif
+ #endif /* VK_USE_PLATFORM_MIR_KHR */
+
+@@ -3448,11 +3558,12 @@ VkResult VKAPI vkCreateAndroidSurfaceKHR(
+ #define vk_ext_khr_win32_surface 1
+ #include <windows.h>
+
+-#define VK_EXT_KHR_WIN32_SURFACE_REVISION 1
++#define VK_EXT_KHR_WIN32_SURFACE_REVISION 2
+ #define VK_EXT_KHR_WIN32_SURFACE_EXTENSION_NUMBER 10
+ #define VK_EXT_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_EXT_KHR_win32_surface"
+
+ typedef VkResult (VKAPI *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, HINSTANCE hinstance, HWND hwnd, VkSurfaceKHR* pSurface);
++typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
+
+ #ifdef VK_PROTOTYPES
+ VkResult VKAPI vkCreateWin32SurfaceKHR(
+@@ -3460,6 +3571,10 @@ VkResult VKAPI vkCreateWin32SurfaceKHR(
+ HINSTANCE hinstance,
+ HWND hwnd,
+ VkSurfaceKHR* pSurface);
++
++VkBool32 VKAPI vkGetPhysicalDeviceWin32PresentationSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ uint32_t queueFamilyIndex);
+ #endif
+ #endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 386acbf..1360862 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -212,18 +212,8 @@ void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDev
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo) {
+- return GetVtbl(queue).QueueBindSparseBufferMemory(queue, buffer, bindInfoCount, pBindInfo);
+-}
+-
+-__attribute__((visibility("default")))
+-VkResult vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo) {
+- return GetVtbl(queue).QueueBindSparseImageOpaqueMemory(queue, image, bindInfoCount, pBindInfo);
+-}
+-
+-__attribute__((visibility("default")))
+-VkResult vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseImageMemoryBindInfo* pBindInfo) {
+- return GetVtbl(queue).QueueBindSparseImageMemory(queue, image, bindInfoCount, pBindInfo);
++VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
++ return GetVtbl(queue).QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+ }
+
+ __attribute__((visibility("default")))
+@@ -752,7 +742,7 @@ void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface) {
+ }
+
+ __attribute__((visibility("default")))
+-VkBool32 vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface) {
++VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface) {
+ return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface);
+ }
+
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
+index 68a77d5..a0987e2 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp
++++ b/vulkan/libvulkan/get_proc_addr.cpp
+@@ -188,9 +188,7 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges)},
+ {"vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory)},
+ {"vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(vkMergePipelineCaches)},
+- {"vkQueueBindSparseBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparseBufferMemory)},
+- {"vkQueueBindSparseImageMemory", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparseImageMemory)},
+- {"vkQueueBindSparseImageOpaqueMemory", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparseImageOpaqueMemory)},
++ {"vkQueueBindSparse", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparse)},
+ {"vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR)},
+ {"vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit)},
+ {"vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle)},
+@@ -347,9 +345,7 @@ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ {"vkInvalidateMappedMemoryRanges", offsetof(DeviceVtbl, InvalidateMappedMemoryRanges)},
+ {"vkMapMemory", offsetof(DeviceVtbl, MapMemory)},
+ {"vkMergePipelineCaches", offsetof(DeviceVtbl, MergePipelineCaches)},
+- {"vkQueueBindSparseBufferMemory", offsetof(DeviceVtbl, QueueBindSparseBufferMemory)},
+- {"vkQueueBindSparseImageMemory", offsetof(DeviceVtbl, QueueBindSparseImageMemory)},
+- {"vkQueueBindSparseImageOpaqueMemory", offsetof(DeviceVtbl, QueueBindSparseImageOpaqueMemory)},
++ {"vkQueueBindSparse", offsetof(DeviceVtbl, QueueBindSparse)},
+ {"vkQueuePresentKHR", offsetof(DeviceVtbl, QueuePresentKHR)},
+ {"vkQueueSubmit", offsetof(DeviceVtbl, QueueSubmit)},
+ {"vkQueueWaitIdle", offsetof(DeviceVtbl, QueueWaitIdle)},
+@@ -591,19 +587,9 @@ bool LoadDeviceVtbl(VkDevice device,
+ ALOGE("missing device proc: %s", "vkGetImageSparseMemoryRequirements");
+ success = false;
+ }
+- vtbl.QueueBindSparseBufferMemory = reinterpret_cast<PFN_vkQueueBindSparseBufferMemory>(get_proc_addr(device, "vkQueueBindSparseBufferMemory"));
+- if (UNLIKELY(!vtbl.QueueBindSparseBufferMemory)) {
+- ALOGE("missing device proc: %s", "vkQueueBindSparseBufferMemory");
+- success = false;
+- }
+- vtbl.QueueBindSparseImageOpaqueMemory = reinterpret_cast<PFN_vkQueueBindSparseImageOpaqueMemory>(get_proc_addr(device, "vkQueueBindSparseImageOpaqueMemory"));
+- if (UNLIKELY(!vtbl.QueueBindSparseImageOpaqueMemory)) {
+- ALOGE("missing device proc: %s", "vkQueueBindSparseImageOpaqueMemory");
+- success = false;
+- }
+- vtbl.QueueBindSparseImageMemory = reinterpret_cast<PFN_vkQueueBindSparseImageMemory>(get_proc_addr(device, "vkQueueBindSparseImageMemory"));
+- if (UNLIKELY(!vtbl.QueueBindSparseImageMemory)) {
+- ALOGE("missing device proc: %s", "vkQueueBindSparseImageMemory");
++ vtbl.QueueBindSparse = reinterpret_cast<PFN_vkQueueBindSparse>(get_proc_addr(device, "vkQueueBindSparse"));
++ if (UNLIKELY(!vtbl.QueueBindSparse)) {
++ ALOGE("missing device proc: %s", "vkQueueBindSparse");
+ success = false;
+ }
+ vtbl.CreateFence = reinterpret_cast<PFN_vkCreateFence>(get_proc_addr(device, "vkCreateFence"));
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp.tmpl b/vulkan/libvulkan/get_proc_addr.cpp.tmpl
+index c6ec0d1..217647f 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp.tmpl
++++ b/vulkan/libvulkan/get_proc_addr.cpp.tmpl
+@@ -279,7 +279,7 @@ bool LoadDeviceVtbl(VkDevice device,
+ {{$ext := index $.Arguments 0}}
+ {{ if eq $ext "VK_EXT_KHR_display"}}true
+ {{else if eq $ext "VK_EXT_KHR_display_swapchain"}}true
+- {{else if eq $ext "VK_EXT_KHR_x11_surface"}}true
++ {{else if eq $ext "VK_EXT_KHR_xlib_surface"}}true
+ {{else if eq $ext "VK_EXT_KHR_xcb_surface"}}true
+ {{else if eq $ext "VK_EXT_KHR_wayland_surface"}}true
+ {{else if eq $ext "VK_EXT_KHR_mir_surface"}}true
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index e166887..5c176db 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -136,9 +136,7 @@ struct DeviceVtbl {
+
+ PFN_vkQueueSubmit QueueSubmit;
+ PFN_vkQueueWaitIdle QueueWaitIdle;
+- PFN_vkQueueBindSparseBufferMemory QueueBindSparseBufferMemory;
+- PFN_vkQueueBindSparseImageOpaqueMemory QueueBindSparseImageOpaqueMemory;
+- PFN_vkQueueBindSparseImageMemory QueueBindSparseImageMemory;
++ PFN_vkQueueBindSparse QueueBindSparse;
+
+ PFN_vkBeginCommandBuffer BeginCommandBuffer;
+ PFN_vkEndCommandBuffer EndCommandBuffer;
+@@ -268,7 +266,7 @@ VkResult CreateAndroidSurfaceKHR(VkInstance instance,
+ ANativeWindow* window,
+ VkSurfaceKHR* surface);
+ void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface);
+-VkBool32 GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev,
++VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev,
+ uint32_t queue_family,
+ VkSurfaceKHR surface);
+ VkResult GetSurfacePropertiesKHR(VkDevice device,
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index f6ab081..8861918 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -175,10 +175,10 @@ void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface_handle) {
+ FreeMem(instance, surface);
+ }
+
+-VkBool32 GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
++VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
+ uint32_t /*queue_family*/,
+ VkSurfaceKHR /*surface*/) {
+- return VK_TRUE;
++ return VK_SUCCESS;
+ }
+
+ VkResult GetSurfacePropertiesKHR(VkDevice /*device*/,
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 9c56982..d6a879e 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -815,17 +815,7 @@ void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevic
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ }
+
+-VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
+- ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+-}
+-
+-VkResult QueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
+- ALOGV("TODO: vk%s", __FUNCTION__);
+- return VK_SUCCESS;
+-}
+-
+-VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo) {
++VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ return VK_SUCCESS;
+ }
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index dd6dc6b..70283c4 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -60,9 +60,7 @@ void GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequi
+ void GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+ void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+ void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+-VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+-VkResult QueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+-VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
++VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
+ VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkFence* pFence);
+ void DestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* allocator);
+ VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
+diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
+index a026bbf..f836a70 100644
+--- a/vulkan/nulldrv/null_driver_gen.cpp
++++ b/vulkan/nulldrv/null_driver_gen.cpp
+@@ -178,9 +178,7 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkInvalidateMappedMemoryRanges>(InvalidateMappedMemoryRanges))},
+ {"vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkMapMemory>(MapMemory))},
+ {"vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkMergePipelineCaches>(MergePipelineCaches))},
+- {"vkQueueBindSparseBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueBindSparseBufferMemory>(QueueBindSparseBufferMemory))},
+- {"vkQueueBindSparseImageMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueBindSparseImageMemory>(QueueBindSparseImageMemory))},
+- {"vkQueueBindSparseImageOpaqueMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueBindSparseImageOpaqueMemory>(QueueBindSparseImageOpaqueMemory))},
++ {"vkQueueBindSparse", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueBindSparse>(QueueBindSparse))},
+ {"vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueSubmit>(QueueSubmit))},
+ {"vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueWaitIdle>(QueueWaitIdle))},
+ {"vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkResetCommandBuffer>(ResetCommandBuffer))},
+--
+2.4.0
+
--- /dev/null
+From f31710155f9bfdd726bc95f648a821d84de55b69 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Sun, 29 Nov 2015 19:12:15 -0800
+Subject: [PATCH 15/30] vulkan: Update from version 0.190.0 to 0.192.0
+
+Change-Id: I5d38543a4ae1c522cacb45a3c011ceab62d2e1d5
+---
+ vulkan/api/vulkan.api | 33 ++++++++++++++++++---------------
+ vulkan/include/vulkan/vulkan.h | 38 ++++++++++++++++++++------------------
+ vulkan/libvulkan/entry.cpp | 4 ++--
+ vulkan/nulldrv/null_driver.cpp | 2 +-
+ vulkan/nulldrv/null_driver.h | 2 +-
+ 5 files changed, 42 insertions(+), 37 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 0c6a3cc..d2a15b5 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 190
++define VERSION_MINOR 192
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -1149,6 +1149,12 @@ type VkFlags VkFramebufferCreateFlags
+ //bitfield VkFramebufferCreateFlagBits {
+ //}
+
++/// Dependency flags
++type VkFlags VkDependencyFlags
++bitfield VkDependencyFlagBits {
++ VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
++}
++
+ @extension("VK_EXT_KHR_swapchain")
+ type VkFlags VkSurfaceTransformFlagsKHR
+ @extension("VK_EXT_KHR_swapchain")
+@@ -2019,7 +2025,7 @@ class VkSubpassDependency {
+ VkPipelineStageFlags destStageMask
+ VkMemoryOutputFlags outputMask
+ VkMemoryInputFlags inputMask
+- VkBool32 byRegion
++ VkDependencyFlags dependencyFlags
+ }
+
+ class VkRenderPassCreateInfo {
+@@ -2071,12 +2077,9 @@ class VkPhysicalDeviceFeatures {
+ VkBool32 textureCompressionBC /// BC1-7 texture compressed formats
+ VkBool32 occlusionQueryNonConservative /// non-conservative (exact) occlusion queries
+ VkBool32 pipelineStatisticsQuery /// pipeline statistics query
+- VkBool32 vertexSideEffects /// storage buffers and images in vertex stage
+- VkBool32 tessellationSideEffects /// storage buffers and images in tessellation stage
+- VkBool32 geometrySideEffects /// storage buffers and images in geometry stage
+- VkBool32 fragmentSideEffects /// storage buffers and images in fragment stage
+- VkBool32 shaderTessellationPointSize /// tessellation stage can export point size
+- VkBool32 shaderGeometryPointSize /// geometry stage can export point size
++ VkBool32 vertexPipelineStoresAndAtomics
++ VkBool32 fragmentStoresAndAtomics
++ VkBool32 shaderTessellationAndGeometryPointSize
+ VkBool32 shaderImageGatherExtended /// texture gather with run-time values and independent offsets
+ VkBool32 shaderStorageImageExtendedFormats /// the extended set of formats can be used for storage images
+ VkBool32 shaderStorageImageMultisample /// multisample images can be used for storage images
+@@ -2179,10 +2182,10 @@ class VkPhysicalDeviceLimits {
+ f32[2] viewportBoundsRange /// viewport bounds range (min,max)
+ u32 viewportSubPixelBits /// num bits of subpixel precision for viewport
+
+- u32 minMemoryMapAlignment /// min required alignment of pointers returned by MapMemory (bytes)
+- u32 minTexelBufferOffsetAlignment /// min required alignment for texel buffer offsets (bytes)
+- u32 minUniformBufferOffsetAlignment /// min required alignment for uniform buffer sizes and offsets (bytes)
+- u32 minStorageBufferOffsetAlignment /// min required alignment for storage buffer offsets (bytes)
++ platform.size_t minMemoryMapAlignment /// min required alignment of pointers returned by MapMemory (bytes)
++ VkDeviceSize minTexelBufferOffsetAlignment /// min required alignment for texel buffer offsets (bytes)
++ VkDeviceSize minUniformBufferOffsetAlignment /// min required alignment for uniform buffer sizes and offsets (bytes)
++ VkDeviceSize minStorageBufferOffsetAlignment /// min required alignment for storage buffer offsets (bytes)
+
+ s32 minTexelOffset /// min texel offset for OpTextureSampleOffset
+ u32 maxTexelOffset /// max texel offset for OpTextureSampleOffset
+@@ -2220,8 +2223,8 @@ class VkPhysicalDeviceLimits {
+ f32 lineWidthGranularity /// granularity of supported line widths
+ VkBool32 strictLines
+
+- u32 recommendedBufferCopyOffsetAlignment
+- u32 recommendedBufferCopyRowPitchAlignment
++ VkDeviceSize recommendedBufferCopyOffsetAlignment
++ VkDeviceSize recommendedBufferCopyRowPitchAlignment
+ }
+
+ class VkPhysicalDeviceSparseProperties {
+@@ -4486,7 +4489,7 @@ cmd void vkCmdPipelineBarrier(
+ VkCmdBuffer cmdBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags destStageMask,
+- VkBool32 byRegion,
++ VkDependencyFlags dependencyFlags,
+ u32 memBarrierCount,
+ const void* const* ppMemBarriers) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index dcc5301..fd09209 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -1,5 +1,5 @@
+-#ifndef __vulkanext_h_
+-#define __vulkanext_h_ 1
++#ifndef __vulkan_h_
++#define __vulkan_h_ 1
+
+ #ifdef __cplusplus
+ extern "C" {
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 190, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 192, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -1018,6 +1018,11 @@ typedef enum {
+ typedef VkFlags VkMemoryInputFlags;
+
+ typedef enum {
++ VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
++} VkDependencyFlagBits;
++typedef VkFlags VkDependencyFlags;
++
++typedef enum {
+ VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
+ VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
+ } VkCmdPoolCreateFlagBits;
+@@ -1138,12 +1143,9 @@ typedef struct {
+ VkBool32 textureCompressionBC;
+ VkBool32 occlusionQueryNonConservative;
+ VkBool32 pipelineStatisticsQuery;
+- VkBool32 vertexSideEffects;
+- VkBool32 tessellationSideEffects;
+- VkBool32 geometrySideEffects;
+- VkBool32 fragmentSideEffects;
+- VkBool32 shaderTessellationPointSize;
+- VkBool32 shaderGeometryPointSize;
++ VkBool32 vertexPipelineStoresAndAtomics;
++ VkBool32 fragmentStoresAndAtomics;
++ VkBool32 shaderTessellationAndGeometryPointSize;
+ VkBool32 shaderImageGatherExtended;
+ VkBool32 shaderStorageImageExtendedFormats;
+ VkBool32 shaderStorageImageMultisample;
+@@ -1253,10 +1255,10 @@ typedef struct {
+ uint32_t maxViewportDimensions[2];
+ float viewportBoundsRange[2];
+ uint32_t viewportSubPixelBits;
+- uint32_t minMemoryMapAlignment;
+- uint32_t minTexelBufferOffsetAlignment;
+- uint32_t minUniformBufferOffsetAlignment;
+- uint32_t minStorageBufferOffsetAlignment;
++ size_t minMemoryMapAlignment;
++ VkDeviceSize minTexelBufferOffsetAlignment;
++ VkDeviceSize minUniformBufferOffsetAlignment;
++ VkDeviceSize minStorageBufferOffsetAlignment;
+ int32_t minTexelOffset;
+ uint32_t maxTexelOffset;
+ int32_t minTexelGatherOffset;
+@@ -1286,8 +1288,8 @@ typedef struct {
+ float pointSizeGranularity;
+ float lineWidthGranularity;
+ VkBool32 strictLines;
+- uint32_t recommendedBufferCopyOffsetAlignment;
+- uint32_t recommendedBufferCopyRowPitchAlignment;
++ VkDeviceSize recommendedBufferCopyOffsetAlignment;
++ VkDeviceSize recommendedBufferCopyRowPitchAlignment;
+ } VkPhysicalDeviceLimits;
+
+ typedef struct {
+@@ -1974,7 +1976,7 @@ typedef struct {
+ VkPipelineStageFlags destStageMask;
+ VkMemoryOutputFlags outputMask;
+ VkMemoryInputFlags inputMask;
+- VkBool32 byRegion;
++ VkDependencyFlags dependencyFlags;
+ } VkSubpassDependency;
+
+ typedef struct {
+@@ -2280,7 +2282,7 @@ typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcIm
+ typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+ typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+ typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+-typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers);
++typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+ typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+ typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+ typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+@@ -3029,7 +3031,7 @@ void VKAPI vkCmdPipelineBarrier(
+ VkCmdBuffer cmdBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags destStageMask,
+- VkBool32 byRegion,
++ VkDependencyFlags dependencyFlags,
+ uint32_t memBarrierCount,
+ const void* const* ppMemBarriers);
+
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 1360862..9198f64 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -682,8 +682,8 @@ void vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent*
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+- GetVtbl(cmdBuffer).CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
++void vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
++ GetVtbl(cmdBuffer).CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, dependencyFlags, memBarrierCount, ppMemBarriers);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index d6a879e..698dbd0 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -1050,7 +1050,7 @@ void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags st
+ void CmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+ }
+
+-void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
++void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+ }
+
+ void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 70283c4..5f3e53e 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -154,7 +154,7 @@ void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcI
+ void CmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+ void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+ void CmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+-void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers);
++void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+ void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+ void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+ void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+--
+2.4.0
+
--- /dev/null
+From 45aa1055a77ee030591c989f737ff7c4f635a46b Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Sun, 29 Nov 2015 19:46:20 -0800
+Subject: [PATCH 16/30] vulkan: Update from version 0.192.0 to 0.193.0
+
+Change-Id: I4387b28368c38c5165c1da99d8dc4e632ad2b42a
+---
+ vulkan/api/vulkan.api | 127 ++++++++++++++-------------
+ vulkan/include/vulkan/vulkan.h | 171 ++++++++++++++++++-------------------
+ vulkan/libvulkan/entry.cpp | 32 +++----
+ vulkan/libvulkan/get_proc_addr.cpp | 30 ++-----
+ vulkan/libvulkan/loader.cpp | 12 +--
+ vulkan/libvulkan/loader.h | 32 +++----
+ vulkan/libvulkan/swapchain.cpp | 45 +++++-----
+ vulkan/tools/vkinfo.cpp | 2 +-
+ 8 files changed, 218 insertions(+), 233 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index d2a15b5..bd3049c 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 192
++define VERSION_MINOR 193
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -726,7 +726,7 @@ bitfield VkQueueFlagBits {
+ VK_QUEUE_GRAPHICS_BIT = 0x00000001, /// Queue supports graphics operations
+ VK_QUEUE_COMPUTE_BIT = 0x00000002, /// Queue supports compute operations
+ VK_QUEUE_DMA_BIT = 0x00000004, /// Queue supports DMA operations
+- VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008, /// Queue supports sparse resource memory management operations
++ VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, /// Queue supports sparse resource memory management operations
+ }
+
+ /// Memory properties passed into vkAllocMemory().
+@@ -840,12 +840,10 @@ bitfield VkImageCreateFlagBits {
+ VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, /// Allows creating image views with cube type from the created image
+ }
+
+-/// Framebuffer attachment view creation flags
++/// Image view creation flags
+ type VkFlags VkImageViewCreateFlags
+-bitfield VkImageViewCreateFlagBits {
+- VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
+- VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
+-}
++//bitfield VkImageViewCreateFlagBits {
++//}
+
+ /// Pipeline creation flags
+ type VkFlags VkPipelineCreateFlags
+@@ -970,9 +968,9 @@ bitfield VkSparseMemoryBindFlagBits {
+ /// Sparse image memory requirements flags
+ type VkFlags VkSparseImageFormatFlags
+ bitfield VkSparseImageFormatFlagBits {
+- VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001, /// Image uses a single miptail region for all array slices
+- VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002, /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels.
+- VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004, /// Image uses a non-standard sparse block size
++ VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, /// Image uses a single miptail region for all array slices
++ VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels.
++ VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, /// Image uses a non-standard sparse block size
+ }
+
+ /// Pipeline stages
+@@ -1363,7 +1361,7 @@ class VkSparseImageFormatProperties {
+ }
+
+ class VkSparseImageMemoryRequirements {
+- VkSparseImageFormatProperties formatProps
++ VkSparseImageFormatProperties formatProperties
+ u32 imageMipTailStartLOD
+ VkDeviceSize imageMipTailSize /// Specified in bytes, must be a multiple of image block size / alignment
+ VkDeviceSize imageMipTailOffset /// Specified in bytes, must be a multiple of image block size / alignment
+@@ -1545,14 +1543,14 @@ class VkImageViewCreateInfo {
+ class VkBufferCopy {
+ VkDeviceSize srcOffset /// Specified in bytes
+ VkDeviceSize destOffset /// Specified in bytes
+- VkDeviceSize copySize /// Specified in bytes
++ VkDeviceSize size /// Specified in bytes
+ }
+
+ class VkSparseMemoryBind {
+- VkDeviceSize rangeOffset /// Specified in bytes
+- VkDeviceSize rangeSize /// Specified in bytes
+- VkDeviceSize memOffset /// Specified in bytes
++ VkDeviceSize resourceOffset /// Specified in bytes
++ VkDeviceSize size /// Specified in bytes
+ VkDeviceMemory mem
++ VkDeviceSize memOffset /// Specified in bytes
+ VkSparseMemoryBindFlags flags
+ }
+
+@@ -1560,8 +1558,8 @@ class VkSparseImageMemoryBind {
+ VkImageSubresource subresource
+ VkOffset3D offset
+ VkExtent3D extent
+- VkDeviceSize memOffset /// Specified in bytes
+ VkDeviceMemory mem
++ VkDeviceSize memOffset /// Specified in bytes
+ VkSparseMemoryBindFlags flags
+ }
+
+@@ -1695,13 +1693,13 @@ class VkDescriptorSetAllocInfo {
+
+ class VkSpecializationMapEntry {
+ u32 constantId /// The SpecConstant ID specified in the BIL
+- platform.size_t size /// Size in bytes of the SpecConstant
+ u32 offset /// Offset of the value in the data block
++ platform.size_t size /// Size in bytes of the SpecConstant
+ }
+
+ class VkSpecializationInfo {
+ u32 mapEntryCount /// Number of entries in the map
+- const VkSpecializationMapEntry* pMap /// Array of map entries
++ const VkSpecializationMapEntry* pMapEntries /// Array of map entries
+ platform.size_t dataSize /// Size in bytes of pData
+ const void* pData /// Pointer to SpecConstant data
+ }
+@@ -1725,16 +1723,16 @@ class VkComputePipelineCreateInfo {
+ }
+
+ class VkVertexInputBindingDescription {
+- u32 binding /// Vertex buffer binding id
+- u32 strideInBytes /// Distance between vertices in bytes (0 = no advancement)
+- VkVertexInputStepRate stepRate /// Rate at which binding is incremented
++ u32 binding /// Vertex buffer binding id
++ u32 stride /// Distance between vertices in bytes (0 = no advancement)
++ VkVertexInputStepRate stepRate /// Rate at which binding is incremented
+ }
+
+ class VkVertexInputAttributeDescription {
+- u32 location /// location of the shader vertex attrib
+- u32 binding /// Vertex buffer binding id
+- VkFormat format /// format of source data
+- u32 offsetInBytes /// Offset of first element in bytes from base of vertex
++ u32 location /// location of the shader vertex attrib
++ u32 binding /// Vertex buffer binding id
++ VkFormat format /// format of source data
++ u32 offset /// Offset of first element in bytes from base of vertex
+ }
+
+ class VkPipelineVertexInputStateCreateInfo {
+@@ -1819,7 +1817,7 @@ class VkPipelineColorBlendStateCreateInfo {
+ VkLogicOp logicOp
+ u32 attachmentCount /// # of pAttachments
+ const VkPipelineColorBlendAttachmentState* pAttachments
+- f32[4] blendConst
++ f32[4] blendConstants
+ }
+
+ class VkStencilOpState {
+@@ -1878,12 +1876,12 @@ class VkGraphicsPipelineCreateInfo {
+ }
+
+ class VkPipelineCacheCreateInfo {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
+- const void* pNext /// Pointer to next structure
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
++ const void* pNext /// Pointer to next structure
+ VkPipelineCacheCreateFlags flags
+- platform.size_t initialSize /// Size of initial data to populate cache, in bytes
+- const void* initialData /// Initial data to populate cache
+- platform.size_t maxSize /// Maximum size cache can grow to, in bytes. If zero, then the cache may grow without bound.
++ platform.size_t initialDataSize /// Size of initial data to populate cache, in bytes
++ const void* pInitialData /// Initial data to populate cache
++ platform.size_t maxSize /// Maximum size cache can grow to, in bytes. If zero, then the cache may grow without bound.
+ }
+
+ class VkPushConstantRange {
+@@ -2113,7 +2111,7 @@ class VkPhysicalDeviceLimits {
+ u32 maxImageDimensionCube /// max cubemap image dimension
+ u32 maxImageArrayLayers /// max layers for image arrays
+ VkSampleCountFlags sampleCounts /// sample counts supported for all images supporting rendering and sampling
+- u32 maxTexelBufferSize /// max texel buffer size (bytes)
++ u32 maxTexelBufferElements
+ u32 maxUniformBufferRange /// max uniform buffer size (bytes)
+ u32 maxStorageBufferRange /// max storage buffer size (bytes)
+ u32 maxPushConstantsSize /// max size of the push constants pool (bytes)
+@@ -2229,7 +2227,7 @@ class VkPhysicalDeviceLimits {
+
+ class VkPhysicalDeviceSparseProperties {
+ VkBool32 residencyStandard2DBlockShape /// Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard block shapes (based on pixel format)
+- VkBool32 residencyStandard2DMSBlockShape /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format)
++ VkBool32 residencyStandard2DMultisampleBlockShape /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format)
+ VkBool32 residencyStandard3DBlockShape /// Sparse resources support: GPU will access all 3D sparse resources using the standard block shapes (based on pixel format)
+ VkBool32 residencyAlignedMipSize /// Sparse resources support: Images with mip-level dimensions that are NOT a multiple of the block size will be placed in the mip tail
+ VkBool32 residencyNonResident /// Sparse resources support: GPU can safely access non-resident regions of a resource, read values from read-write resources are undefined
+@@ -2284,8 +2282,8 @@ class VkDispatchIndirectCmd {
+ u32 z
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
+-class VkSurfacePropertiesKHR {
++@extension("VK_EXT_KHR_surface")
++class VkSurfaceCapabilitiesKHR {
+ u32 minImageCount
+ u32 maxImageCount
+ VkExtent2D currentExtent
+@@ -2298,7 +2296,7 @@ class VkSurfacePropertiesKHR {
+ VkImageUsageFlags supportedUsageFlags
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_EXT_KHR_surface")
+ class VkSurfaceFormatKHR {
+ VkFormat format
+ VkColorSpaceKHR colorSpace
+@@ -2329,6 +2327,8 @@ class VkSwapchainCreateInfoKHR {
+ class VkPresentInfoKHR {
+ VkStructureType sType
+ const void* pNext
++ u32 waitSemaphoreCount
++ const VkSemaphore* pWaitSemaphores
+ u32 swapchainCount
+ const VkSwapchainKHR* pSwapchains
+ const u32* imageIndices
+@@ -2727,7 +2727,7 @@ cmd void vkGetDeviceQueue(
+ cmd VkResult vkQueueSubmit(
+ VkQueue queue,
+ u32 submitCount,
+- const VkSubmitInfo* pSubmitInfo,
++ const VkSubmitInfo* pSubmits,
+ VkFence fence) {
+ queueObject := GetQueue(queue)
+
+@@ -3709,21 +3709,21 @@ cmd VkResult vkFreeDescriptorSets(
+
+ cmd void vkUpdateDescriptorSets(
+ VkDevice device,
+- u32 writeCount,
++ u32 descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+- u32 copyCount,
++ u32 descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies) {
+ deviceObject := GetDevice(device)
+
+- descriptorWrites := pDescriptorWrites[0:writeCount]
+- for i in (0 .. writeCount) {
++ descriptorWrites := pDescriptorWrites[0:descriptorWriteCount]
++ for i in (0 .. descriptorWriteCount) {
+ descriptorWrite := descriptorWrites[i]
+ descriptorWriteObject := GetDescriptorSet(descriptorWrite.destSet)
+ assert(descriptorWriteObject.device == device)
+ }
+
+- descriptorCopies := pDescriptorCopies[0:copyCount]
+- for i in (0 .. copyCount) {
++ descriptorCopies := pDescriptorCopies[0:descriptorCopyCount]
++ for i in (0 .. descriptorCopyCount) {
+ descriptorCopy := descriptorCopies[i]
+ descriptorCopyObject := GetDescriptorSet(descriptorCopy.destSet)
+ assert(descriptorCopyObject.device == device)
+@@ -3987,7 +3987,7 @@ cmd void vkCmdSetBlendConstants(
+ // TODO(jessehall): apic only supports 'const' on pointer types. Using
+ // an annotation as a quick hack to pass this to the template without
+ // having to modify the AST and semantic model.
+- @readonly f32[4] blendConst) {
++ @readonly f32[4] blendConstants) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+@@ -4330,7 +4330,7 @@ cmd void vkCmdFillBuffer(
+ VkCmdBuffer cmdBuffer,
+ VkBuffer destBuffer,
+ VkDeviceSize destOffset,
+- VkDeviceSize fillSize,
++ VkDeviceSize size,
+ u32 data) {
+ cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ destBufferObject := GetBuffer(destBuffer)
+@@ -4643,34 +4643,33 @@ cmd void vkDestroySurfaceKHR(
+ cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ u32 queueFamilyIndex,
+- VkSurfaceKHR surface) {
++ VkSurfaceKHR surface,
++ VkBool32* pSupported) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+
+- //supported := ?
+-
+- return ?//supported
++ return ?
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
+-cmd VkResult vkGetSurfacePropertiesKHR(
+- VkDevice device,
++@extension("VK_EXT_KHR_surface")
++cmd VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
++ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+- VkSurfacePropertiesKHR* pSurfaceProperties) {
+- deviceObject := GetDevice(device)
++ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+
+- surfaceProperties := ?
+- pSurfaceProperties[0] = surfaceProperties
++ surfaceCapabilities := ?
++ pSurfaceCapabilities[0] = surfaceCapabilities
+
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
+-cmd VkResult vkGetSurfaceFormatsKHR(
+- VkDevice device,
++@extension("VK_EXT_KHR_surface")
++cmd VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
++ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ u32* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats) {
+- deviceObject := GetDevice(device)
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+
+ count := as!u32(?)
+ pSurfaceFormatCount[0] = count
+@@ -4684,13 +4683,13 @@ cmd VkResult vkGetSurfaceFormatsKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
+-cmd VkResult vkGetSurfacePresentModesKHR(
+- VkDevice device,
++@extension("VK_EXT_KHR_surface")
++cmd VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
++ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ u32* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes) {
+- deviceObject := GetDevice(device)
++ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+
+ count := as!u32(?)
+ pPresentModeCount[0] = count
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index fd09209..8442325 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 192, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 193, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -818,7 +818,7 @@ typedef enum {
+ VK_QUEUE_GRAPHICS_BIT = 0x00000001,
+ VK_QUEUE_COMPUTE_BIT = 0x00000002,
+ VK_QUEUE_DMA_BIT = 0x00000004,
+- VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008,
++ VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
+ } VkQueueFlagBits;
+ typedef VkFlags VkQueueFlags;
+
+@@ -847,9 +847,9 @@ typedef enum {
+ } VkImageAspectFlagBits;
+
+ typedef enum {
+- VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001,
+- VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
+- VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004,
++ VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
++ VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
++ VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
+ } VkSparseImageFormatFlagBits;
+ typedef VkFlags VkSparseImageFormatFlags;
+
+@@ -910,11 +910,6 @@ typedef enum {
+ } VkBufferUsageFlagBits;
+ typedef VkFlags VkBufferUsageFlags;
+ typedef VkFlags VkBufferViewCreateFlags;
+-
+-typedef enum {
+- VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
+- VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
+-} VkImageViewCreateFlagBits;
+ typedef VkFlags VkImageViewCreateFlags;
+ typedef VkFlags VkImageAspectFlags;
+ typedef VkFlags VkShaderModuleCreateFlags;
+@@ -1198,7 +1193,7 @@ typedef struct {
+ uint32_t maxImageDimensionCube;
+ uint32_t maxImageArrayLayers;
+ VkSampleCountFlags sampleCounts;
+- uint32_t maxTexelBufferSize;
++ uint32_t maxTexelBufferElements;
+ uint32_t maxUniformBufferRange;
+ uint32_t maxStorageBufferRange;
+ uint32_t maxPushConstantsSize;
+@@ -1294,7 +1289,7 @@ typedef struct {
+
+ typedef struct {
+ VkBool32 residencyStandard2DBlockShape;
+- VkBool32 residencyStandard2DMSBlockShape;
++ VkBool32 residencyStandard2DMultisampleBlockShape;
+ VkBool32 residencyStandard3DBlockShape;
+ VkBool32 residencyAlignedMipSize;
+ VkBool32 residencyNonResident;
+@@ -1409,7 +1404,7 @@ typedef struct {
+ } VkSparseImageFormatProperties;
+
+ typedef struct {
+- VkSparseImageFormatProperties formatProps;
++ VkSparseImageFormatProperties formatProperties;
+ uint32_t imageMipTailStartLOD;
+ VkDeviceSize imageMipTailSize;
+ VkDeviceSize imageMipTailOffset;
+@@ -1417,10 +1412,10 @@ typedef struct {
+ } VkSparseImageMemoryRequirements;
+
+ typedef struct {
+- VkDeviceSize rangeOffset;
+- VkDeviceSize rangeSize;
+- VkDeviceSize memOffset;
++ VkDeviceSize resourceOffset;
++ VkDeviceSize size;
+ VkDeviceMemory mem;
++ VkDeviceSize memOffset;
+ VkSparseMemoryBindFlags flags;
+ } VkSparseMemoryBind;
+
+@@ -1452,8 +1447,8 @@ typedef struct {
+ VkImageSubresource subresource;
+ VkOffset3D offset;
+ VkExtent3D extent;
+- VkDeviceSize memOffset;
+ VkDeviceMemory mem;
++ VkDeviceSize memOffset;
+ VkSparseMemoryBindFlags flags;
+ } VkSparseImageMemoryBind;
+
+@@ -1598,20 +1593,20 @@ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineCacheCreateFlags flags;
+- size_t initialSize;
+- const void* initialData;
++ size_t initialDataSize;
++ const void* pInitialData;
+ size_t maxSize;
+ } VkPipelineCacheCreateInfo;
+
+ typedef struct {
+ uint32_t constantId;
+- size_t size;
+ uint32_t offset;
++ size_t size;
+ } VkSpecializationMapEntry;
+
+ typedef struct {
+ uint32_t mapEntryCount;
+- const VkSpecializationMapEntry* pMap;
++ const VkSpecializationMapEntry* pMapEntries;
+ size_t dataSize;
+ const void* pData;
+ } VkSpecializationInfo;
+@@ -1626,7 +1621,7 @@ typedef struct {
+
+ typedef struct {
+ uint32_t binding;
+- uint32_t strideInBytes;
++ uint32_t stride;
+ VkVertexInputStepRate stepRate;
+ } VkVertexInputBindingDescription;
+
+@@ -1634,7 +1629,7 @@ typedef struct {
+ uint32_t location;
+ uint32_t binding;
+ VkFormat format;
+- uint32_t offsetInBytes;
++ uint32_t offset;
+ } VkVertexInputAttributeDescription;
+
+ typedef struct {
+@@ -1768,7 +1763,7 @@ typedef struct {
+ VkLogicOp logicOp;
+ uint32_t attachmentCount;
+ const VkPipelineColorBlendAttachmentState* pAttachments;
+- float blendConst[4];
++ float blendConstants[4];
+ } VkPipelineColorBlendStateCreateInfo;
+
+ typedef struct {
+@@ -2018,7 +2013,7 @@ typedef struct {
+ typedef struct {
+ VkDeviceSize srcOffset;
+ VkDeviceSize destOffset;
+- VkDeviceSize copySize;
++ VkDeviceSize size;
+ } VkBufferCopy;
+
+ typedef struct {
+@@ -2172,7 +2167,7 @@ typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDev
+ typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+ typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+ typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+-typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
++typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
+ typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
+ typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
+ typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem);
+@@ -2235,7 +2230,7 @@ typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorP
+ typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+ typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
+ typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
+-typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
++typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+ typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
+ typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass);
+@@ -2254,7 +2249,7 @@ typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCmdBuffer cmdBuffer, uint32_t viewp
+ typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
+ typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth);
+ typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
+-typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConst[4]);
++typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConstants[4]);
+ typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
+ typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
+ typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
+@@ -2274,7 +2269,7 @@ typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage
+ typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+ typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+ typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
+-typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
++typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data);
+ typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+ typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+ typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+@@ -2387,7 +2382,7 @@ void VKAPI vkGetDeviceQueue(
+ VkResult VKAPI vkQueueSubmit(
+ VkQueue queue,
+ uint32_t submitCount,
+- const VkSubmitInfo* pSubmitInfo,
++ const VkSubmitInfo* pSubmits,
+ VkFence fence);
+
+ VkResult VKAPI vkQueueWaitIdle(
+@@ -2738,9 +2733,9 @@ VkResult VKAPI vkFreeDescriptorSets(
+
+ void VKAPI vkUpdateDescriptorSets(
+ VkDevice device,
+- uint32_t writeCount,
++ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+- uint32_t copyCount,
++ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies);
+
+ VkResult VKAPI vkCreateFramebuffer(
+@@ -2835,7 +2830,7 @@ void VKAPI vkCmdSetDepthBias(
+
+ void VKAPI vkCmdSetBlendConstants(
+ VkCmdBuffer cmdBuffer,
+- const float blendConst[4]);
++ const float blendConstants[4]);
+
+ void VKAPI vkCmdSetDepthBounds(
+ VkCmdBuffer cmdBuffer,
+@@ -2973,7 +2968,7 @@ void VKAPI vkCmdFillBuffer(
+ VkCmdBuffer cmdBuffer,
+ VkBuffer destBuffer,
+ VkDeviceSize destOffset,
+- VkDeviceSize fillSize,
++ VkDeviceSize size,
+ uint32_t data);
+
+ void VKAPI vkCmdClearColorImage(
+@@ -3102,32 +3097,6 @@ VK_DEFINE_NONDISP_HANDLE(VkSurfaceKHR)
+ #define VK_EXT_KHR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_surface"
+ #define VK_ERROR_SURFACE_LOST_KHR ((VkResult)(int)0xc0000400)
+
+-typedef void (VKAPI *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface);
+-
+-#ifdef VK_PROTOTYPES
+-void VKAPI vkDestroySurfaceKHR(
+- VkInstance instance,
+- VkSurfaceKHR surface);
+-
+-VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
+- VkPhysicalDevice physicalDevice,
+- uint32_t queueFamilyIndex,
+- VkSurfaceKHR surface);
+-#endif
+-
+-#define vk_ext_khr_swapchain 1
+-VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR)
+-
+-#define VK_EXT_KHR_SWAPCHAIN_REVISION 62
+-#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+-#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
+-#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
+-#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801)
+-#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR ((VkImageLayout)(int)0xc0000802)
+-#define VK_SUBOPTIMAL_KHR ((VkResult)(int)0x40000403)
+-#define VK_ERROR_OUT_OF_DATE_KHR ((VkResult)(int)0xc0000804)
+-
+
+ typedef enum {
+ VK_SURFACE_TRANSFORM_NONE_KHR = 0,
+@@ -3197,13 +3166,61 @@ typedef struct {
+ VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
+ uint32_t maxImageArraySize;
+ VkImageUsageFlags supportedUsageFlags;
+-} VkSurfacePropertiesKHR;
++} VkSurfaceCapabilitiesKHR;
+
+ typedef struct {
+ VkFormat format;
+ VkColorSpaceKHR colorSpace;
+ } VkSurfaceFormatKHR;
+
++
++typedef void (VKAPI *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface);
++typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
++typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
++typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
++typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
++
++#ifdef VK_PROTOTYPES
++void VKAPI vkDestroySurfaceKHR(
++ VkInstance instance,
++ VkSurfaceKHR surface);
++
++VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
++ VkPhysicalDevice physicalDevice,
++ uint32_t queueFamilyIndex,
++ VkSurfaceKHR surface,
++ VkBool32* pSupported);
++
++VkResult VKAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
++ VkPhysicalDevice physicalDevice,
++ VkSurfaceKHR surface,
++ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
++
++VkResult VKAPI vkGetPhysicalDeviceSurfaceFormatsKHR(
++ VkPhysicalDevice physicalDevice,
++ VkSurfaceKHR surface,
++ uint32_t* pSurfaceFormatCount,
++ VkSurfaceFormatKHR* pSurfaceFormats);
++
++VkResult VKAPI vkGetPhysicalDeviceSurfacePresentModesKHR(
++ VkPhysicalDevice physicalDevice,
++ VkSurfaceKHR surface,
++ uint32_t* pPresentModeCount,
++ VkPresentModeKHR* pPresentModes);
++#endif
++
++#define vk_ext_khr_swapchain 1
++VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR)
++
++#define VK_EXT_KHR_SWAPCHAIN_REVISION 62
++#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
++#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
++#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
++#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801)
++#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR ((VkImageLayout)(int)0xc0000802)
++#define VK_SUBOPTIMAL_KHR ((VkResult)(int)0x40000403)
++#define VK_ERROR_OUT_OF_DATE_KHR ((VkResult)(int)0xc0000804)
++
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+@@ -3227,15 +3244,14 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
++ uint32_t waitSemaphoreCount;
++ const VkSemaphore* pWaitSemaphores;
+ uint32_t swapchainCount;
+ const VkSwapchainKHR* pSwapchains;
+ const uint32_t* imageIndices;
+ } VkPresentInfoKHR;
+
+
+-typedef VkResult (VKAPI *PFN_vkGetSurfacePropertiesKHR)(VkDevice device, VkSurfaceKHR surface, VkSurfacePropertiesKHR* pSurfaceProperties);
+-typedef VkResult (VKAPI *PFN_vkGetSurfaceFormatsKHR)(VkDevice device, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
+-typedef VkResult (VKAPI *PFN_vkGetSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
+ typedef VkResult (VKAPI *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain);
+ typedef void (VKAPI *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain);
+ typedef VkResult (VKAPI *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
+@@ -3243,23 +3259,6 @@ typedef VkResult (VKAPI *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchai
+ typedef VkResult (VKAPI *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo);
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkGetSurfacePropertiesKHR(
+- VkDevice device,
+- VkSurfaceKHR surface,
+- VkSurfacePropertiesKHR* pSurfaceProperties);
+-
+-VkResult VKAPI vkGetSurfaceFormatsKHR(
+- VkDevice device,
+- VkSurfaceKHR surface,
+- uint32_t* pSurfaceFormatCount,
+- VkSurfaceFormatKHR* pSurfaceFormats);
+-
+-VkResult VKAPI vkGetSurfacePresentModesKHR(
+- VkDevice device,
+- VkSurfaceKHR surface,
+- uint32_t* pPresentModeCount,
+- VkPresentModeKHR* pPresentModes);
+-
+ VkResult VKAPI vkCreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+@@ -3333,11 +3332,6 @@ typedef struct {
+ } VkDisplayModeCreateInfoKHR;
+
+ typedef struct {
+- VkDisplayKHR currentDisplay;
+- uint32_t currentStackIndex;
+-} VkDisplayPlanePropertiesKHR;
+-
+-typedef struct {
+ VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
+ VkOffset2D minSrcPosition;
+ VkOffset2D maxSrcPosition;
+@@ -3350,6 +3344,11 @@ typedef struct {
+ } VkDisplayPlaneCapabilitiesKHR;
+
+ typedef struct {
++ VkDisplayKHR currentDisplay;
++ uint32_t currentStackIndex;
++} VkDisplayPlanePropertiesKHR;
++
++typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ VkDisplayModeKHR displayMode;
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 9198f64..31f0231 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -132,8 +132,8 @@ void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queue
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence) {
+- return GetVtbl(queue).QueueSubmit(queue, submitCount, pSubmitInfo, fence);
++VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
++ return GetVtbl(queue).QueueSubmit(queue, submitCount, pSubmits, fence);
+ }
+
+ __attribute__((visibility("default")))
+@@ -447,8 +447,8 @@ VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+ }
+
+ __attribute__((visibility("default")))
+-void vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
+- GetVtbl(device).UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
++void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
++ GetVtbl(device).UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+ }
+
+ __attribute__((visibility("default")))
+@@ -542,8 +542,8 @@ void vkCmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, flo
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConst[4]) {
+- GetVtbl(cmdBuffer).CmdSetBlendConstants(cmdBuffer, blendConst);
++void vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConstants[4]) {
++ GetVtbl(cmdBuffer).CmdSetBlendConstants(cmdBuffer, blendConstants);
+ }
+
+ __attribute__((visibility("default")))
+@@ -642,8 +642,8 @@ void vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
+- GetVtbl(cmdBuffer).CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
++void vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data) {
++ GetVtbl(cmdBuffer).CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+ }
+
+ __attribute__((visibility("default")))
+@@ -742,23 +742,23 @@ void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface) {
+- return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface);
++VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
++ return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetSurfacePropertiesKHR(VkDevice device, VkSurfaceKHR surface, VkSurfacePropertiesKHR* pSurfaceProperties) {
+- return GetVtbl(device).GetSurfacePropertiesKHR(device, surface, pSurfaceProperties);
++VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
++ return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetSurfaceFormatsKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
+- return GetVtbl(device).GetSurfaceFormatsKHR(device, surface, pSurfaceFormatCount, pSurfaceFormats);
++VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
++ return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
+- return GetVtbl(device).GetSurfacePresentModesKHR(device, surface, pPresentModeCount, pPresentModes);
++VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
++ return GetVtbl(physicalDevice).GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
+index a0987e2..4e08015 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp
++++ b/vulkan/libvulkan/get_proc_addr.cpp
+@@ -64,6 +64,9 @@ const NameProcEntry kInstanceProcTbl[] = {
+ {"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties)},
+ {"vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyProperties)},
+ {"vkGetPhysicalDeviceSparseImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSparseImageFormatProperties)},
++ {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)},
++ {"vkGetPhysicalDeviceSurfaceFormatsKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceFormatsKHR)},
++ {"vkGetPhysicalDeviceSurfacePresentModesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfacePresentModesKHR)},
+ {"vkGetPhysicalDeviceSurfaceSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceSupportKHR)},
+ // clang-format on
+ };
+@@ -181,9 +184,6 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData)},
+ {"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults)},
+ {"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity)},
+- {"vkGetSurfaceFormatsKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfaceFormatsKHR)},
+- {"vkGetSurfacePresentModesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfacePresentModesKHR)},
+- {"vkGetSurfacePropertiesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfacePropertiesKHR)},
+ {"vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR)},
+ {"vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges)},
+ {"vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory)},
+@@ -221,6 +221,9 @@ const NameOffsetEntry kInstanceOffsetTbl[] = {
+ {"vkGetPhysicalDeviceProperties", offsetof(InstanceVtbl, GetPhysicalDeviceProperties)},
+ {"vkGetPhysicalDeviceQueueFamilyProperties", offsetof(InstanceVtbl, GetPhysicalDeviceQueueFamilyProperties)},
+ {"vkGetPhysicalDeviceSparseImageFormatProperties", offsetof(InstanceVtbl, GetPhysicalDeviceSparseImageFormatProperties)},
++ {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfaceCapabilitiesKHR)},
++ {"vkGetPhysicalDeviceSurfaceFormatsKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfaceFormatsKHR)},
++ {"vkGetPhysicalDeviceSurfacePresentModesKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfacePresentModesKHR)},
+ {"vkGetPhysicalDeviceSurfaceSupportKHR", offsetof(InstanceVtbl, GetPhysicalDeviceSurfaceSupportKHR)},
+ // clang-format on
+ };
+@@ -338,9 +341,6 @@ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ {"vkGetPipelineCacheData", offsetof(DeviceVtbl, GetPipelineCacheData)},
+ {"vkGetQueryPoolResults", offsetof(DeviceVtbl, GetQueryPoolResults)},
+ {"vkGetRenderAreaGranularity", offsetof(DeviceVtbl, GetRenderAreaGranularity)},
+- {"vkGetSurfaceFormatsKHR", offsetof(DeviceVtbl, GetSurfaceFormatsKHR)},
+- {"vkGetSurfacePresentModesKHR", offsetof(DeviceVtbl, GetSurfacePresentModesKHR)},
+- {"vkGetSurfacePropertiesKHR", offsetof(DeviceVtbl, GetSurfacePropertiesKHR)},
+ {"vkGetSwapchainImagesKHR", offsetof(DeviceVtbl, GetSwapchainImagesKHR)},
+ {"vkInvalidateMappedMemoryRanges", offsetof(DeviceVtbl, InvalidateMappedMemoryRanges)},
+ {"vkMapMemory", offsetof(DeviceVtbl, MapMemory)},
+@@ -486,6 +486,9 @@ bool LoadInstanceVtbl(VkInstance instance,
+ }
+ vtbl.DestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(get_proc_addr(instance, "vkDestroySurfaceKHR"));
+ vtbl.GetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"));
++ vtbl.GetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
++ vtbl.GetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
++ vtbl.GetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
+ vtbl.CreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(get_proc_addr(instance, "vkCreateAndroidSurfaceKHR"));
+ // clang-format on
+ return success;
+@@ -1112,21 +1115,6 @@ bool LoadDeviceVtbl(VkDevice device,
+ ALOGE("missing device proc: %s", "vkCmdExecuteCommands");
+ success = false;
+ }
+- vtbl.GetSurfacePropertiesKHR = reinterpret_cast<PFN_vkGetSurfacePropertiesKHR>(get_proc_addr(device, "vkGetSurfacePropertiesKHR"));
+- if (UNLIKELY(!vtbl.GetSurfacePropertiesKHR)) {
+- ALOGE("missing device proc: %s", "vkGetSurfacePropertiesKHR");
+- success = false;
+- }
+- vtbl.GetSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetSurfaceFormatsKHR>(get_proc_addr(device, "vkGetSurfaceFormatsKHR"));
+- if (UNLIKELY(!vtbl.GetSurfaceFormatsKHR)) {
+- ALOGE("missing device proc: %s", "vkGetSurfaceFormatsKHR");
+- success = false;
+- }
+- vtbl.GetSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetSurfacePresentModesKHR>(get_proc_addr(device, "vkGetSurfacePresentModesKHR"));
+- if (UNLIKELY(!vtbl.GetSurfacePresentModesKHR)) {
+- ALOGE("missing device proc: %s", "vkGetSurfacePresentModesKHR");
+- success = false;
+- }
+ vtbl.CreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(get_proc_addr(device, "vkCreateSwapchainKHR"));
+ if (UNLIKELY(!vtbl.CreateSwapchainKHR)) {
+ ALOGE("missing device proc: %s", "vkCreateSwapchainKHR");
+diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
+index d5795d7..4e68f88 100644
+--- a/vulkan/libvulkan/loader.cpp
++++ b/vulkan/libvulkan/loader.cpp
+@@ -542,15 +542,6 @@ PFN_vkVoidFunction GetLayerDeviceProcAddr(VkDevice device, const char* name) {
+ return reinterpret_cast<PFN_vkVoidFunction>(Noop);
+ }
+ // WSI extensions are not in the driver so return the loader functions
+- if (strcmp(name, "vkGetSurfacePropertiesKHR") == 0) {
+- return reinterpret_cast<PFN_vkVoidFunction>(GetSurfacePropertiesKHR);
+- }
+- if (strcmp(name, "vkGetSurfaceFormatsKHR") == 0) {
+- return reinterpret_cast<PFN_vkVoidFunction>(GetSurfaceFormatsKHR);
+- }
+- if (strcmp(name, "vkGetSurfacePresentModesKHR") == 0) {
+- return reinterpret_cast<PFN_vkVoidFunction>(GetSurfacePresentModesKHR);
+- }
+ if (strcmp(name, "vkCreateSwapchainKHR") == 0) {
+ return reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR);
+ }
+@@ -896,6 +887,9 @@ const InstanceVtbl kBottomInstanceFunctions = {
+ .EnumerateDeviceLayerProperties = EnumerateDeviceLayerPropertiesBottom,
+ .GetPhysicalDeviceSparseImageFormatProperties = GetPhysicalDeviceSparseImageFormatPropertiesBottom,
+ .GetPhysicalDeviceSurfaceSupportKHR = GetPhysicalDeviceSurfaceSupportKHR,
++ .GetPhysicalDeviceSurfaceCapabilitiesKHR = GetPhysicalDeviceSurfaceCapabilitiesKHR,
++ .GetPhysicalDeviceSurfaceFormatsKHR = GetPhysicalDeviceSurfaceFormatsKHR,
++ .GetPhysicalDeviceSurfacePresentModesKHR = GetPhysicalDeviceSurfacePresentModesKHR,
+ // clang-format on
+ };
+
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index 5c176db..b6c8552 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -51,6 +51,9 @@ struct InstanceVtbl {
+ PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
+
+ // Layers and loader only, not implemented by drivers
++ PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
++ PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
++ PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
+ PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
+ PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
+ PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
+@@ -187,9 +190,6 @@ struct DeviceVtbl {
+ PFN_vkCmdExecuteCommands CmdExecuteCommands;
+
+ // Layers and loader only, not implemented by drivers
+- PFN_vkGetSurfacePropertiesKHR GetSurfacePropertiesKHR;
+- PFN_vkGetSurfaceFormatsKHR GetSurfaceFormatsKHR;
+- PFN_vkGetSurfacePresentModesKHR GetSurfacePresentModesKHR;
+ PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
+ PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
+ PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
+@@ -268,18 +268,20 @@ VkResult CreateAndroidSurfaceKHR(VkInstance instance,
+ void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface);
+ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev,
+ uint32_t queue_family,
+- VkSurfaceKHR surface);
+-VkResult GetSurfacePropertiesKHR(VkDevice device,
+- VkSurfaceKHR surface,
+- VkSurfacePropertiesKHR* properties);
+-VkResult GetSurfaceFormatsKHR(VkDevice device,
+- VkSurfaceKHR surface,
+- uint32_t* count,
+- VkSurfaceFormatKHR* formats);
+-VkResult GetSurfacePresentModesKHR(VkDevice device,
+- VkSurfaceKHR surface,
+- uint32_t* count,
+- VkPresentModeKHR* modes);
++ VkSurfaceKHR surface,
++ VkBool32* pSupported);
++VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
++ VkPhysicalDevice pdev,
++ VkSurfaceKHR surface,
++ VkSurfaceCapabilitiesKHR* capabilities);
++VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
++ VkSurfaceKHR surface,
++ uint32_t* count,
++ VkSurfaceFormatKHR* formats);
++VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
++ VkSurfaceKHR surface,
++ uint32_t* count,
++ VkPresentModeKHR* modes);
+ VkResult CreateSwapchainKHR(VkDevice device,
+ const VkSwapchainCreateInfoKHR* create_info,
+ VkSwapchainKHR* swapchain_handle);
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index 8861918..f1fe236 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -177,13 +177,16 @@ void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface_handle) {
+
+ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
+ uint32_t /*queue_family*/,
+- VkSurfaceKHR /*surface*/) {
++ VkSurfaceKHR /*surface*/,
++ VkBool32* pSupported) {
++ *pSupported = VK_TRUE;
+ return VK_SUCCESS;
+ }
+
+-VkResult GetSurfacePropertiesKHR(VkDevice /*device*/,
+- VkSurfaceKHR surface,
+- VkSurfacePropertiesKHR* properties) {
++VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
++ VkPhysicalDevice /*pdev*/,
++ VkSurfaceKHR surface,
++ VkSurfaceCapabilitiesKHR* capabilities) {
+ int err;
+ ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
+
+@@ -201,25 +204,25 @@ VkResult GetSurfacePropertiesKHR(VkDevice /*device*/,
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+- properties->currentExtent = VkExtent2D{width, height};
++ capabilities->currentExtent = VkExtent2D{width, height};
+
+ // TODO(jessehall): Figure out what the min/max values should be.
+- properties->minImageCount = 2;
+- properties->maxImageCount = 3;
++ capabilities->minImageCount = 2;
++ capabilities->maxImageCount = 3;
+
+ // TODO(jessehall): Figure out what the max extent should be. Maximum
+ // texture dimension maybe?
+- properties->minImageExtent = VkExtent2D{1, 1};
+- properties->maxImageExtent = VkExtent2D{4096, 4096};
++ capabilities->minImageExtent = VkExtent2D{1, 1};
++ capabilities->maxImageExtent = VkExtent2D{4096, 4096};
+
+ // TODO(jessehall): We can support all transforms, fix this once
+ // implemented.
+- properties->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_KHR;
++ capabilities->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_KHR;
+
+ // TODO(jessehall): Implement based on NATIVE_WINDOW_TRANSFORM_HINT.
+- properties->currentTransform = VK_SURFACE_TRANSFORM_NONE_KHR;
++ capabilities->currentTransform = VK_SURFACE_TRANSFORM_NONE_KHR;
+
+- properties->maxImageArraySize = 1;
++ capabilities->maxImageArraySize = 1;
+
+ // TODO(jessehall): I think these are right, but haven't thought hard about
+ // it. Do we need to query the driver for support of any of these?
+@@ -227,7 +230,7 @@ VkResult GetSurfacePropertiesKHR(VkDevice /*device*/,
+ // - VK_IMAGE_USAGE_GENERAL: maybe? does this imply cpu mappable?
+ // - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT: definitely not
+ // - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: definitely not
+- properties->supportedUsageFlags =
++ capabilities->supportedUsageFlags =
+ VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT |
+ VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
+ VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+@@ -236,10 +239,10 @@ VkResult GetSurfacePropertiesKHR(VkDevice /*device*/,
+ return VK_SUCCESS;
+ }
+
+-VkResult GetSurfaceFormatsKHR(VkDevice /*device*/,
+- VkSurfaceKHR /*surface*/,
+- uint32_t* count,
+- VkSurfaceFormatKHR* formats) {
++VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice /*pdev*/,
++ VkSurfaceKHR /*surface*/,
++ uint32_t* count,
++ VkSurfaceFormatKHR* formats) {
+ // TODO(jessehall): Fill out the set of supported formats. Longer term, add
+ // a new gralloc method to query whether a (format, usage) pair is
+ // supported, and check that for each gralloc format that corresponds to a
+@@ -262,10 +265,10 @@ VkResult GetSurfaceFormatsKHR(VkDevice /*device*/,
+ return result;
+ }
+
+-VkResult GetSurfacePresentModesKHR(VkDevice /*device*/,
+- VkSurfaceKHR /*surface*/,
+- uint32_t* count,
+- VkPresentModeKHR* modes) {
++VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice /*pdev*/,
++ VkSurfaceKHR /*surface*/,
++ uint32_t* count,
++ VkPresentModeKHR* modes) {
+ const VkPresentModeKHR kModes[] = {
+ VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR,
+ };
+diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
+index 63e0d5f..eaec272 100644
+--- a/vulkan/tools/vkinfo.cpp
++++ b/vulkan/tools/vkinfo.cpp
+@@ -77,7 +77,7 @@ const char* VkQueueFlagBitStr(VkQueueFlagBits bit) {
+ return "COMPUTE";
+ case VK_QUEUE_DMA_BIT:
+ return "DMA";
+- case VK_QUEUE_SPARSE_MEMMGR_BIT:
++ case VK_QUEUE_SPARSE_BINDING_BIT:
+ return "SPARSE";
+ }
+ }
+--
+2.4.0
+
--- /dev/null
+From 3b2e2ef030d38b5c2a6e200a4d5ccdaea36ec906 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Sun, 29 Nov 2015 21:05:26 -0800
+Subject: [PATCH 17/30] vulkan: Update from version 0.193.0 to 0.194.0
+
+Change-Id: I6a4508a61414375112bae3ffd16b0490ce3e4294
+---
+ vulkan/api/vulkan.api | 163 +++++++++++++++++-----------------
+ vulkan/include/vulkan/vulkan.h | 196 ++++++++++++++++++++---------------------
+ 2 files changed, 174 insertions(+), 185 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index bd3049c..418318a 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 193
++define VERSION_MINOR 194
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -170,8 +170,8 @@ enum VkImageType {
+ }
+
+ enum VkImageTiling {
+- VK_IMAGE_TILING_LINEAR = 0x00000000,
+- VK_IMAGE_TILING_OPTIMAL = 0x00000001,
++ VK_IMAGE_TILING_OPTIMAL = 0x00000000,
++ VK_IMAGE_TILING_LINEAR = 0x00000001,
+ }
+
+ enum VkImageViewType {
+@@ -190,12 +190,13 @@ enum VkCmdBufferLevel {
+ }
+
+ enum VkChannelSwizzle {
+- VK_CHANNEL_SWIZZLE_ZERO = 0x00000000,
+- VK_CHANNEL_SWIZZLE_ONE = 0x00000001,
+- VK_CHANNEL_SWIZZLE_R = 0x00000002,
+- VK_CHANNEL_SWIZZLE_G = 0x00000003,
+- VK_CHANNEL_SWIZZLE_B = 0x00000004,
+- VK_CHANNEL_SWIZZLE_A = 0x00000005,
++ VK_CHANNEL_SWIZZLE_IDENTITY = 0x00000000,
++ VK_CHANNEL_SWIZZLE_ZERO = 0x00000001,
++ VK_CHANNEL_SWIZZLE_ONE = 0x00000002,
++ VK_CHANNEL_SWIZZLE_R = 0x00000003,
++ VK_CHANNEL_SWIZZLE_G = 0x00000004,
++ VK_CHANNEL_SWIZZLE_B = 0x00000005,
++ VK_CHANNEL_SWIZZLE_A = 0x00000006,
+ }
+
+ enum VkDescriptorType {
+@@ -228,8 +229,8 @@ enum VkBorderColor {
+ }
+
+ enum VkPipelineBindPoint {
+- VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000000,
+- VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001,
++ VK_PIPELINE_BIND_POINT_GRAPHICS = 0x00000000,
++ VK_PIPELINE_BIND_POINT_COMPUTE = 0x00000001,
+ }
+
+ enum VkPrimitiveTopology {
+@@ -268,11 +269,11 @@ enum VkSamplerMipmapMode {
+ }
+
+ enum VkSamplerAddressMode {
+- VK_SAMPLER_ADDRESS_MODE_WRAP = 0x00000000,
+- VK_SAMPLER_ADDRESS_MODE_MIRROR = 0x00000001,
+- VK_SAMPLER_ADDRESS_MODE_CLAMP = 0x00000002,
+- VK_SAMPLER_ADDRESS_MODE_MIRROR_ONCE = 0x00000003,
+- VK_SAMPLER_ADDRESS_MODE_CLAMP_BORDER = 0x00000004,
++ VK_SAMPLER_ADDRESS_MODE_REPEAT = 0x00000000,
++ VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 0x00000001,
++ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 0x00000002,
++ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 0x00000003,
++ VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 0x00000004,
+ }
+
+ enum VkCompareOp {
+@@ -287,16 +288,9 @@ enum VkCompareOp {
+ }
+
+ enum VkFillMode {
+- VK_FILL_MODE_POINTS = 0x00000000,
++ VK_FILL_MODE_SOLID = 0x00000000,
+ VK_FILL_MODE_WIREFRAME = 0x00000001,
+- VK_FILL_MODE_SOLID = 0x00000002,
+-}
+-
+-enum VkCullMode {
+- VK_CULL_MODE_NONE = 0x00000000,
+- VK_CULL_MODE_FRONT = 0x00000001,
+- VK_CULL_MODE_BACK = 0x00000002,
+- VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
++ VK_FILL_MODE_POINTS = 0x00000002,
+ }
+
+ enum VkFrontFace {
+@@ -570,57 +564,54 @@ enum VkFormat {
+ /// Structure type enumerant
+ enum VkStructureType {
+ VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
+- VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
+- VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
+- VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3,
+- VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 4,
+- VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 5,
+- VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 6,
+- VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 7,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 8,
+- VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 9,
++ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
++ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
++ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
++ VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
++ VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 5,
++ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
++ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
++ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
++ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
+ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
+- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 11,
+- VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 12,
+- VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 13,
+- VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 14,
+- VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 15,
+- VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 16,
+- VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 17,
+- VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 18,
+- VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 19,
+- VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 20,
+- VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 21,
+- VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 22,
+- VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 23,
+- VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 24,
+- VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 25,
+- VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 26,
+- VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 27,
+- VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 28,
+- VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 29,
+- VK_STRUCTURE_TYPE_MEMORY_BARRIER = 30,
+- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 31,
+- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 32,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
+- VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 34,
+- VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 35,
+- VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 36,
+- VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 37,
+- VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 38,
+- VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 39,
+- VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 40,
+- VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 41,
+- VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 42,
++ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
++ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
++ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
++ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
++ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
++ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
++ VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 17,
++ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 18,
++ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19,
++ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 20,
++ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 21,
++ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 22,
++ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 23,
++ VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 24,
++ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 25,
++ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 26,
++ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
++ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 28,
++ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 29,
++ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 30,
++ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 31,
++ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 32,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 33,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 34,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 35,
++ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 36,
++ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 37,
++ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 38,
++ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 39,
++ VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 40,
++ VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 41,
++ VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 42,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
+- VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 44,
+- VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45,
+- VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 47,
+- VK_STRUCTURE_TYPE_SUBMIT_INFO = 48,
+- VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 49,
+- VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 50,
+- VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 51,
++ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
++ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
++ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
++ VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 47,
++ VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 48,
+
+ //@extension("VK_EXT_KHR_swapchain")
+ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 0xc0000801,
+@@ -802,6 +793,7 @@ bitfield VkShaderStageFlagBits {
+ VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
+ VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
+ VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
++ VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
+
+ VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+ }
+@@ -1040,6 +1032,7 @@ bitfield VkStencilFaceFlagBits {
+ VK_STENCIL_FACE_NONE = 0x00000000, /// No faces
+ VK_STENCIL_FACE_FRONT_BIT = 0x00000001, /// Front face
+ VK_STENCIL_FACE_BACK_BIT = 0x00000002, /// Back face
++ VK_STENCIL_FRONT_AND_BACK = 0x00000003,
+ }
+
+ /// Instance creation flags
+@@ -1153,6 +1146,15 @@ bitfield VkDependencyFlagBits {
+ VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
+ }
+
++/// Cull mode flags
++type VkFlags VkCullModeFlags
++bitfield VkCullModeFlagBits {
++ VK_CULL_MODE_NONE = 0x00000000,
++ VK_CULL_MODE_FRONT_BIT = 0x00000001,
++ VK_CULL_MODE_BACK_BIT = 0x00000002,
++ VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
++}
++
+ @extension("VK_EXT_KHR_swapchain")
+ type VkFlags VkSurfaceTransformFlagsKHR
+ @extension("VK_EXT_KHR_swapchain")
+@@ -1777,7 +1779,7 @@ class VkPipelineRasterStateCreateInfo {
+ VkBool32 depthClampEnable
+ VkBool32 rasterizerDiscardEnable
+ VkFillMode fillMode /// optional (GL45)
+- VkCullMode cullMode
++ VkCullModeFlags cullMode
+ VkFrontFace frontFace
+ VkBool32 depthBiasEnable
+ f32 depthBiasConstantFactor
+@@ -1981,8 +1983,6 @@ class VkClearAttachment {
+ }
+
+ class VkAttachmentDescription {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION
+- const void* pNext /// Pointer to next structure
+ VkAttachmentDescriptionFlags flags
+ VkFormat format
+ u32 samples
+@@ -2000,8 +2000,6 @@ class VkAttachmentReference {
+ }
+
+ class VkSubpassDescription {
+- VkStructureType sType /// Must be VK_STRUCTURE_SUBPASS_DESCRIPTION
+- const void* pNext /// Pointer to next structure
+ VkSubpassDescriptionFlags flags
+ VkPipelineBindPoint pipelineBindPoint /// Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now
+ u32 inputAttachmentCount
+@@ -2009,14 +2007,12 @@ class VkSubpassDescription {
+ u32 colorAttachmentCount
+ const VkAttachmentReference* pColorAttachments
+ const VkAttachmentReference* pResolveAttachments
+- VkAttachmentReference depthStencilAttachment
++ const VkAttachmentReference* pDepthStencilAttachment
+ u32 preserveAttachmentCount
+ const VkAttachmentReference* pPreserveAttachments
+ }
+
+ class VkSubpassDependency {
+- VkStructureType sType /// Must be VK_STRUCTURE_SUBPASS_DEPENDENCY
+- const void* pNext /// Pointer to next structure
+ u32 srcSubpass
+ u32 destSubpass
+ VkPipelineStageFlags srcStageMask
+@@ -2202,7 +2198,8 @@ class VkPhysicalDeviceLimits {
+ u32 maxColorAttachments /// max num of framebuffer color attachments
+
+ u32 maxSampledImageColorSamples /// max num of color samples for a non-integer sampled image
+- u32 maxSampledImageDepthSamples /// max num of depth/stencil samples for a sampled image
++ u32 maxSampledImageDepthSamples /// max num of depth samples for a sampled image
++ u32 maxSampledImageStencilSamples /// max num of stencil samples for a sampled image
+ u32 maxSampledImageIntegerSamples /// max num of samples supported for an integer image
+ u32 maxStorageImageSamples /// max num of samples for a storage image
+ u32 maxSampleMaskWords /// max num of sample mask words
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 8442325..af0ccdf 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 193, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 194, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -132,60 +132,57 @@ typedef enum {
+
+ typedef enum {
+ VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
+- VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
+- VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
+- VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3,
+- VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 4,
+- VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 5,
+- VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 6,
+- VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 7,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 8,
+- VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 9,
++ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
++ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
++ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
++ VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
++ VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 5,
++ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
++ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
++ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
++ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
+ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
+- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 11,
+- VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 12,
+- VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 13,
+- VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 14,
+- VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 15,
+- VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 16,
+- VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 17,
+- VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 18,
+- VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 19,
+- VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 20,
+- VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 21,
+- VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 22,
+- VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 23,
+- VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 24,
+- VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 25,
+- VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 26,
+- VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 27,
+- VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 28,
+- VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 29,
+- VK_STRUCTURE_TYPE_MEMORY_BARRIER = 30,
+- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 31,
+- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 32,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
+- VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 34,
+- VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 35,
+- VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 36,
+- VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 37,
+- VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 38,
+- VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 39,
+- VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 40,
+- VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 41,
+- VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 42,
++ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
++ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
++ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
++ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
++ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
++ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
++ VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 17,
++ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 18,
++ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19,
++ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 20,
++ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 21,
++ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 22,
++ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 23,
++ VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 24,
++ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 25,
++ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 26,
++ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
++ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 28,
++ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 29,
++ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 30,
++ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 31,
++ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 32,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 33,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 34,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 35,
++ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 36,
++ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 37,
++ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 38,
++ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 39,
++ VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 40,
++ VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 41,
++ VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 42,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
+- VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 44,
+- VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45,
+- VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 47,
+- VK_STRUCTURE_TYPE_SUBMIT_INFO = 48,
+- VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 49,
+- VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 50,
+- VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 51,
++ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
++ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
++ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
++ VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 47,
++ VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 48,
+ VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+- VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,
+- VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_BIND_SPARSE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
++ VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO,
++ VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+ VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkStructureType;
+
+@@ -401,11 +398,11 @@ typedef enum {
+ } VkImageType;
+
+ typedef enum {
+- VK_IMAGE_TILING_LINEAR = 0,
+- VK_IMAGE_TILING_OPTIMAL = 1,
+- VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_LINEAR,
+- VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_OPTIMAL,
+- VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_OPTIMAL - VK_IMAGE_TILING_LINEAR + 1),
++ VK_IMAGE_TILING_OPTIMAL = 0,
++ VK_IMAGE_TILING_LINEAR = 1,
++ VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
++ VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
++ VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
+ VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
+ } VkImageTiling;
+
+@@ -471,15 +468,16 @@ typedef enum {
+ } VkImageViewType;
+
+ typedef enum {
+- VK_CHANNEL_SWIZZLE_ZERO = 0,
+- VK_CHANNEL_SWIZZLE_ONE = 1,
+- VK_CHANNEL_SWIZZLE_R = 2,
+- VK_CHANNEL_SWIZZLE_G = 3,
+- VK_CHANNEL_SWIZZLE_B = 4,
+- VK_CHANNEL_SWIZZLE_A = 5,
+- VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO,
++ VK_CHANNEL_SWIZZLE_IDENTITY = 0,
++ VK_CHANNEL_SWIZZLE_ZERO = 1,
++ VK_CHANNEL_SWIZZLE_ONE = 2,
++ VK_CHANNEL_SWIZZLE_R = 3,
++ VK_CHANNEL_SWIZZLE_G = 4,
++ VK_CHANNEL_SWIZZLE_B = 5,
++ VK_CHANNEL_SWIZZLE_A = 6,
++ VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_IDENTITY,
+ VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A,
+- VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_ZERO + 1),
++ VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_IDENTITY + 1),
+ VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
+ } VkChannelSwizzle;
+
+@@ -511,27 +509,16 @@ typedef enum {
+ } VkPrimitiveTopology;
+
+ typedef enum {
+- VK_FILL_MODE_POINTS = 0,
++ VK_FILL_MODE_SOLID = 0,
+ VK_FILL_MODE_WIREFRAME = 1,
+- VK_FILL_MODE_SOLID = 2,
+- VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_POINTS,
+- VK_FILL_MODE_END_RANGE = VK_FILL_MODE_SOLID,
+- VK_FILL_MODE_NUM = (VK_FILL_MODE_SOLID - VK_FILL_MODE_POINTS + 1),
++ VK_FILL_MODE_POINTS = 2,
++ VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_SOLID,
++ VK_FILL_MODE_END_RANGE = VK_FILL_MODE_POINTS,
++ VK_FILL_MODE_NUM = (VK_FILL_MODE_POINTS - VK_FILL_MODE_SOLID + 1),
+ VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkFillMode;
+
+ typedef enum {
+- VK_CULL_MODE_NONE = 0,
+- VK_CULL_MODE_FRONT = 1,
+- VK_CULL_MODE_BACK = 2,
+- VK_CULL_MODE_FRONT_AND_BACK = 3,
+- VK_CULL_MODE_BEGIN_RANGE = VK_CULL_MODE_NONE,
+- VK_CULL_MODE_END_RANGE = VK_CULL_MODE_FRONT_AND_BACK,
+- VK_CULL_MODE_NUM = (VK_CULL_MODE_FRONT_AND_BACK - VK_CULL_MODE_NONE + 1),
+- VK_CULL_MODE_MAX_ENUM = 0x7FFFFFFF
+-} VkCullMode;
+-
+-typedef enum {
+ VK_FRONT_FACE_CCW = 0,
+ VK_FRONT_FACE_CW = 1,
+ VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW,
+@@ -667,14 +654,14 @@ typedef enum {
+ } VkSamplerMipmapMode;
+
+ typedef enum {
+- VK_SAMPLER_ADDRESS_MODE_WRAP = 0,
+- VK_SAMPLER_ADDRESS_MODE_MIRROR = 1,
+- VK_SAMPLER_ADDRESS_MODE_CLAMP = 2,
+- VK_SAMPLER_ADDRESS_MODE_MIRROR_ONCE = 3,
+- VK_SAMPLER_ADDRESS_MODE_CLAMP_BORDER = 4,
+- VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_WRAP,
+- VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_BORDER,
+- VK_SAMPLER_ADDRESS_MODE_NUM = (VK_SAMPLER_ADDRESS_MODE_CLAMP_BORDER - VK_SAMPLER_ADDRESS_MODE_WRAP + 1),
++ VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
++ VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
++ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
++ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
++ VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
++ VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
++ VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
++ VK_SAMPLER_ADDRESS_MODE_NUM = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
+ VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkSamplerAddressMode;
+
+@@ -729,11 +716,11 @@ typedef enum {
+ } VkAttachmentStoreOp;
+
+ typedef enum {
+- VK_PIPELINE_BIND_POINT_COMPUTE = 0,
+- VK_PIPELINE_BIND_POINT_GRAPHICS = 1,
+- VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
+- VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
+- VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_GRAPHICS - VK_PIPELINE_BIND_POINT_COMPUTE + 1),
++ VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
++ VK_PIPELINE_BIND_POINT_COMPUTE = 1,
++ VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
++ VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
++ VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
+ VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
+ } VkPipelineBindPoint;
+
+@@ -922,6 +909,7 @@ typedef enum {
+ VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
+ VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
+ VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
++ VK_SHADER_STAGE_ALL_GRAPHICS = 0x1F,
+ VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+ } VkShaderStageFlagBits;
+ typedef VkFlags VkPipelineCacheCreateFlags;
+@@ -938,6 +926,14 @@ typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
+ typedef VkFlags VkPipelineTesselationStateCreateFlags;
+ typedef VkFlags VkPipelineViewportStateCreateFlags;
+ typedef VkFlags VkPipelineRasterStateCreateFlags;
++
++typedef enum {
++ VK_CULL_MODE_NONE = 0,
++ VK_CULL_MODE_FRONT_BIT = 0x00000001,
++ VK_CULL_MODE_BACK_BIT = 0x00000002,
++ VK_CULL_MODE_FRONT_AND_BACK = 0x3,
++} VkCullModeFlagBits;
++typedef VkFlags VkCullModeFlags;
+ typedef VkFlags VkPipelineMultisampleStateCreateFlags;
+ typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
+ typedef VkFlags VkPipelineColorBlendStateCreateFlags;
+@@ -1044,6 +1040,7 @@ typedef enum {
+ VK_STENCIL_FACE_NONE = 0,
+ VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
+ VK_STENCIL_FACE_BACK_BIT = 0x00000002,
++ VK_STENCIL_FRONT_AND_BACK = 0x3,
+ } VkStencilFaceFlagBits;
+ typedef VkFlags VkStencilFaceFlags;
+
+@@ -1270,6 +1267,7 @@ typedef struct {
+ uint32_t maxColorAttachments;
+ uint32_t maxSampledImageColorSamples;
+ uint32_t maxSampledImageDepthSamples;
++ uint32_t maxSampledImageStencilSamples;
+ uint32_t maxSampledImageIntegerSamples;
+ uint32_t maxStorageImageSamples;
+ uint32_t maxSampleMaskWords;
+@@ -1698,7 +1696,7 @@ typedef struct {
+ VkBool32 depthClampEnable;
+ VkBool32 rasterizerDiscardEnable;
+ VkFillMode fillMode;
+- VkCullMode cullMode;
++ VkCullModeFlags cullMode;
+ VkFrontFace frontFace;
+ VkBool32 depthBiasEnable;
+ float depthBiasConstantFactor;
+@@ -1929,8 +1927,6 @@ typedef struct {
+ } VkFramebufferCreateInfo;
+
+ typedef struct {
+- VkStructureType sType;
+- const void* pNext;
+ VkAttachmentDescriptionFlags flags;
+ VkFormat format;
+ uint32_t samples;
+@@ -1948,8 +1944,6 @@ typedef struct {
+ } VkAttachmentReference;
+
+ typedef struct {
+- VkStructureType sType;
+- const void* pNext;
+ VkSubpassDescriptionFlags flags;
+ VkPipelineBindPoint pipelineBindPoint;
+ uint32_t inputAttachmentCount;
+@@ -1957,14 +1951,12 @@ typedef struct {
+ uint32_t colorAttachmentCount;
+ const VkAttachmentReference* pColorAttachments;
+ const VkAttachmentReference* pResolveAttachments;
+- VkAttachmentReference depthStencilAttachment;
++ const VkAttachmentReference* pDepthStencilAttachment;
+ uint32_t preserveAttachmentCount;
+ const VkAttachmentReference* pPreserveAttachments;
+ } VkSubpassDescription;
+
+ typedef struct {
+- VkStructureType sType;
+- const void* pNext;
+ uint32_t srcSubpass;
+ uint32_t destSubpass;
+ VkPipelineStageFlags srcStageMask;
+--
+2.4.0
+
--- /dev/null
+From 8d00e63b01003f7269fd31c82698427641eca3bf Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Sun, 29 Nov 2015 22:10:52 -0800
+Subject: [PATCH 18/30] vulkan: Update from version 0.194.0 to 0.196.0
+
+Change-Id: Ib62cc358b1f2575daeaa2a893eb4afca458ec5c3
+---
+ vulkan/api/templates/vulkan_common.tmpl | 2 +-
+ vulkan/api/vulkan.api | 1131 ++++++++++++------------
+ vulkan/include/vulkan/vk_debug_report_lunarg.h | 2 +-
+ vulkan/include/vulkan/vulkan.h | 909 ++++++++++---------
+ vulkan/libvulkan/entry.cpp | 334 +++----
+ vulkan/libvulkan/entry.cpp.tmpl | 6 +-
+ vulkan/libvulkan/get_proc_addr.cpp | 30 +-
+ vulkan/libvulkan/loader.cpp | 98 +-
+ vulkan/libvulkan/loader.h | 19 +-
+ vulkan/libvulkan/swapchain.cpp | 19 +-
+ vulkan/nulldrv/null_driver.cpp | 283 +++---
+ vulkan/nulldrv/null_driver.h | 190 ++--
+ vulkan/nulldrv/null_driver_gen.cpp | 6 +-
+ vulkan/tools/vkinfo.cpp | 2 +-
+ 14 files changed, 1520 insertions(+), 1511 deletions(-)
+
+diff --git a/vulkan/api/templates/vulkan_common.tmpl b/vulkan/api/templates/vulkan_common.tmpl
+index 12d5788..ce37a13 100644
+--- a/vulkan/api/templates/vulkan_common.tmpl
++++ b/vulkan/api/templates/vulkan_common.tmpl
+@@ -211,7 +211,7 @@
+ {{define "Vtbl#VkPhysicalDevice"}}Instance{{end}}
+ {{define "Vtbl#VkDevice" }}Device{{end}}
+ {{define "Vtbl#VkQueue" }}Device{{end}}
+-{{define "Vtbl#VkCmdBuffer" }}Device{{end}}
++{{define "Vtbl#VkCommandBuffer" }}Device{{end}}
+ {{define "Vtbl_Default" }}Global{{end}}
+ {{define "Vtbl"}}
+ {{AssertType $ "Function"}}
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 418318a..7313904 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 194
++define VERSION_MINOR 196
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -100,11 +100,11 @@ type u32 VkSampleMask
+ @dispatchHandle type u64 VkPhysicalDevice
+ @dispatchHandle type u64 VkDevice
+ @dispatchHandle type u64 VkQueue
+-@dispatchHandle type u64 VkCmdBuffer
++@dispatchHandle type u64 VkCommandBuffer
+
+ /// Non dispatchable handle types.
+ @nonDispatchHandle type u64 VkDeviceMemory
+-@nonDispatchHandle type u64 VkCmdPool
++@nonDispatchHandle type u64 VkCommandPool
+ @nonDispatchHandle type u64 VkBuffer
+ @nonDispatchHandle type u64 VkBufferView
+ @nonDispatchHandle type u64 VkImage
+@@ -144,12 +144,12 @@ enum VkImageLayout {
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003, /// Optimal layout when image is only used for depth/stencil attachment read/write
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004, /// Optimal layout when image is used for read only depth/stencil attachment and shader access
+ VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005, /// Optimal layout when image is used for read only shader access
+- VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000006, /// Optimal layout when image is used only as source of transfer operations
+- VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000007, /// Optimal layout when image is used only as destination of transfer operations
++ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 0x00000006, /// Optimal layout when image is used only as source of transfer operations
++ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 0x00000007, /// Optimal layout when image is used only as destination of transfer operations
+ VK_IMAGE_LAYOUT_PREINITIALIZED = 0x00000008, /// Initial layout used when the data is populated by the CPU
+
+ //@extension("VK_EXT_KHR_swapchain")
+- VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR = 0xc0000802,
++ VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 0xc0000802,
+ }
+
+ enum VkAttachmentLoadOp {
+@@ -184,9 +184,9 @@ enum VkImageViewType {
+ VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 0x00000006,
+ }
+
+-enum VkCmdBufferLevel {
+- VK_CMD_BUFFER_LEVEL_PRIMARY = 0x00000000,
+- VK_CMD_BUFFER_LEVEL_SECONDARY = 0x00000001,
++enum VkCommandBufferLevel {
++ VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0x00000000,
++ VK_COMMAND_BUFFER_LEVEL_SECONDARY = 0x00000001,
+ }
+
+ enum VkChannelSwizzle {
+@@ -240,10 +240,10 @@ enum VkPrimitiveTopology {
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 0x00000003,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 0x00000004,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 0x00000005,
+- VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 0x00000006,
+- VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007,
+- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008,
+- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009,
++ VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 0x00000006,
++ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 0x00000007,
++ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 0x00000008,
++ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 0x00000009,
+ VK_PRIMITIVE_TOPOLOGY_PATCH = 0x0000000a,
+ }
+
+@@ -280,10 +280,10 @@ enum VkCompareOp {
+ VK_COMPARE_OP_NEVER = 0x00000000,
+ VK_COMPARE_OP_LESS = 0x00000001,
+ VK_COMPARE_OP_EQUAL = 0x00000002,
+- VK_COMPARE_OP_LESS_EQUAL = 0x00000003,
++ VK_COMPARE_OP_LESS_OR_EQUAL = 0x00000003,
+ VK_COMPARE_OP_GREATER = 0x00000004,
+ VK_COMPARE_OP_NOT_EQUAL = 0x00000005,
+- VK_COMPARE_OP_GREATER_EQUAL = 0x00000006,
++ VK_COMPARE_OP_GREATER_OR_EQUAL = 0x00000006,
+ VK_COMPARE_OP_ALWAYS = 0x00000007,
+ }
+
+@@ -294,8 +294,8 @@ enum VkFillMode {
+ }
+
+ enum VkFrontFace {
+- VK_FRONT_FACE_CCW = 0x00000000,
+- VK_FRONT_FACE_CW = 0x00000001,
++ VK_FRONT_FACE_COUNTER_CLOCKWISE = 0x00000000,
++ VK_FRONT_FACE_CLOCKWISE = 0x00000001,
+ }
+
+ enum VkBlend {
+@@ -303,12 +303,12 @@ enum VkBlend {
+ VK_BLEND_ONE = 0x00000001,
+ VK_BLEND_SRC_COLOR = 0x00000002,
+ VK_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003,
+- VK_BLEND_DEST_COLOR = 0x00000004,
+- VK_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005,
++ VK_BLEND_DST_COLOR = 0x00000004,
++ VK_BLEND_ONE_MINUS_DST_COLOR = 0x00000005,
+ VK_BLEND_SRC_ALPHA = 0x00000006,
+ VK_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007,
+- VK_BLEND_DEST_ALPHA = 0x00000008,
+- VK_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009,
++ VK_BLEND_DST_ALPHA = 0x00000008,
++ VK_BLEND_ONE_MINUS_DST_ALPHA = 0x00000009,
+ VK_BLEND_CONSTANT_COLOR = 0x0000000a,
+ VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
+ VK_BLEND_CONSTANT_ALPHA = 0x0000000c,
+@@ -332,11 +332,11 @@ enum VkStencilOp {
+ VK_STENCIL_OP_KEEP = 0x00000000,
+ VK_STENCIL_OP_ZERO = 0x00000001,
+ VK_STENCIL_OP_REPLACE = 0x00000002,
+- VK_STENCIL_OP_INC_CLAMP = 0x00000003,
+- VK_STENCIL_OP_DEC_CLAMP = 0x00000004,
++ VK_STENCIL_OP_INCREMENT_AND_CLAMP = 0x00000003,
++ VK_STENCIL_OP_DECREMENT_AND_CLAMP = 0x00000004,
+ VK_STENCIL_OP_INVERT = 0x00000005,
+- VK_STENCIL_OP_INC_WRAP = 0x00000006,
+- VK_STENCIL_OP_DEC_WRAP = 0x00000007,
++ VK_STENCIL_OP_INCREMENT_AND_WRAP = 0x00000006,
++ VK_STENCIL_OP_DECREMENT_AND_WRAP = 0x00000007,
+ }
+
+ enum VkLogicOp {
+@@ -345,11 +345,11 @@ enum VkLogicOp {
+ VK_LOGIC_OP_AND_REVERSE = 0x00000002,
+ VK_LOGIC_OP_COPY = 0x00000003,
+ VK_LOGIC_OP_AND_INVERTED = 0x00000004,
+- VK_LOGIC_OP_NOOP = 0x00000005,
++ VK_LOGIC_OP_NO_OP = 0x00000005,
+ VK_LOGIC_OP_XOR = 0x00000006,
+ VK_LOGIC_OP_OR = 0x00000007,
+ VK_LOGIC_OP_NOR = 0x00000008,
+- VK_LOGIC_OP_EQUIV = 0x00000009,
++ VK_LOGIC_OP_EQUIVALENT = 0x00000009,
+ VK_LOGIC_OP_INVERT = 0x0000000a,
+ VK_LOGIC_OP_OR_REVERSE = 0x0000000b,
+ VK_LOGIC_OP_COPY_INVERTED = 0x0000000c,
+@@ -358,16 +358,16 @@ enum VkLogicOp {
+ VK_LOGIC_OP_SET = 0x0000000f,
+ }
+
+-enum VkSystemAllocScope {
+- VK_SYSTEM_ALLOC_SCOPE_FUNCTION = 0x00000000,
+- VK_SYSTEM_ALLOC_SCOPE_OBJECT = 0x00000001,
+- VK_SYSTEM_ALLOC_SCOPE_CACHE = 0x00000002,
+- VK_SYSTEM_ALLOC_SCOPE_DEVICE = 0x00000003,
+- VK_SYSTEM_ALLOC_SCOPE_INSTANCE = 0x00000004,
++enum VkSystemAllocationScope {
++ VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION = 0x00000000,
++ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 0x00000001,
++ VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 0x00000002,
++ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 0x00000003,
++ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 0x00000004,
+ }
+
+-enum VkInternalAllocType {
+- VK_INTERNAL_ALLOC_TYPE_EXECUTABLE = 0x00000000,
++enum VkInternalAllocationType {
++ VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0x00000000,
+ }
+
+ enum VkPhysicalDeviceType {
+@@ -603,9 +603,9 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 37,
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 38,
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 39,
+- VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 40,
+- VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 41,
+- VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 42,
++ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 40,
++ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 41,
++ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
+@@ -627,7 +627,7 @@ enum VkStructureType {
+
+ enum VkRenderPassContents {
+ VK_RENDER_PASS_CONTENTS_INLINE = 0x00000000,
+- VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 0x00000001,
++ VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 0x00000001,
+ }
+
+ @lastUnused(-8)
+@@ -765,8 +765,8 @@ bitfield VkMemoryInputFlagBits {
+ /// Buffer usage flags
+ type VkFlags VkBufferUsageFlags
+ bitfield VkBufferUsageFlagBits {
+- VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, /// Can be used as a source of transfer operations
+- VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, /// Can be used as a destination of transfer operations
++ VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, /// Can be used as a source of transfer operations
++ VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, /// Can be used as a destination of transfer operations
+ VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, /// Can be used as TBO
+ VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, /// Can be used as IBO
+ VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, /// Can be used as UBO
+@@ -812,8 +812,8 @@ type VkFlags VkDescriptorPoolResetFlags
+ /// Image usage flags
+ type VkFlags VkImageUsageFlags
+ bitfield VkImageUsageFlagBits {
+- VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, /// Can be used as a source of transfer operations
+- VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, /// Can be used as a destination of transfer operations
++ VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, /// Can be used as a source of transfer operations
++ VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, /// Can be used as a destination of transfer operations
+ VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, /// Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
+ VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, /// Can be used as storage image (STORAGE_IMAGE descriptor type)
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, /// Can be used as framebuffer color attachment
+@@ -878,8 +878,8 @@ bitfield VkFormatFeatureFlagBits {
+ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, /// Format can be used for color attachment images
+ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, /// Format supports blending in case it's used for color attachment images
+ VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, /// Format can be used for depth/stencil attachment images
+- VK_FORMAT_FEATURE_BLIT_SOURCE_BIT = 0x00000400, /// Format can be used as the source image of blits with vkCmdBlitImage
+- VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT = 0x00000800, /// Format can be used as the destination image of blits with vkCmdBlitImage
++ VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, /// Format can be used as the source image of blits with vkCommandBlitImage
++ VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, /// Format can be used as the destination image of blits with vkCommandBlitImage
+ }
+
+ /// Query control flags
+@@ -914,11 +914,11 @@ type VkFlags VkEventCreateFlags
+ //}
+
+ /// Command buffer usage flags
+-type VkFlags VkCmdBufferUsageFlags
+-bitfield VkCmdBufferUsageFlagBits {
+- VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
+- VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
+- VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
++type VkFlags VkCommandBufferUsageFlags
++bitfield VkCommandBufferUsageFlagBits {
++ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
++ VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
++ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
+ }
+
+ /// Pipeline statistics flags
+@@ -999,21 +999,21 @@ bitfield VkSubpassDescriptionFlagBits {
+ }
+
+ /// Command pool creation flags
+-type VkFlags VkCmdPoolCreateFlags
+-bitfield VkCmdPoolCreateFlagBits {
+- VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001, /// Command buffers have a short lifetime
+- VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, /// Command buffers may release their memory individually
++type VkFlags VkCommandPoolCreateFlags
++bitfield VkCommandPoolCreateFlagBits {
++ VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, /// Command buffers have a short lifetime
++ VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, /// Command buffers may release their memory individually
+ }
+
+ /// Command pool reset flags
+-type VkFlags VkCmdPoolResetFlags
+-bitfield VkCmdPoolResetFlagBits {
+- VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the pool
++type VkFlags VkCommandPoolResetFlags
++bitfield VkCommandPoolResetFlagBits {
++ VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the pool
+ }
+
+-type VkFlags VkCmdBufferResetFlags
+-bitfield VkCmdBufferResetFlagBits {
+- VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the buffer
++type VkFlags VkCommandBufferResetFlags
++bitfield VkCommandBufferResetFlagBits {
++ VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the buffer
+ }
+
+ type VkFlags VkSampleCountFlags
+@@ -1095,9 +1095,9 @@ type VkFlags VkPipelineViewportStateCreateFlags
+ //bitfield VkPipelineViewportStateCreateFlagBits {
+ //}
+
+-/// Raster state creation flags
+-type VkFlags VkPipelineRasterStateCreateFlags
+-//bitfield VkPipelineRasterStateCreateFlagBits {
++/// Rasterization state creation flags
++type VkFlags VkPipelineRasterizationStateCreateFlags
++//bitfield VkPipelineRasterizationStateCreateFlagBits {
+ //}
+
+ /// Multisample state creation flags
+@@ -1233,7 +1233,7 @@ class VkRect2D {
+ class VkClearRect {
+ VkRect2D rect
+ u32 baseArrayLayer
+- u32 numLayers
++ u32 layerCount
+ }
+
+ class VkChannelMapping {
+@@ -1256,15 +1256,15 @@ class VkPhysicalDeviceProperties {
+ }
+
+ class VkExtensionProperties {
+- char[VK_MAX_EXTENSION_NAME] extName /// extension name
++ char[VK_MAX_EXTENSION_NAME] extensionName /// extension name
+ u32 specVersion /// version of the extension specification implemented
+ }
+
+ class VkLayerProperties {
+- char[VK_MAX_EXTENSION_NAME] layerName /// layer name
+- u32 specVersion /// version of the layer specification implemented
+- u32 implVersion /// build or release version of the layer's library
+- char[VK_MAX_DESCRIPTION] description /// Free-form description of the layer
++ char[VK_MAX_EXTENSION_NAME] layerName /// layer name
++ u32 specVersion /// version of the layer specification implemented
++ u32 implementationVersion /// build or release version of the layer's library
++ char[VK_MAX_DESCRIPTION] description /// Free-form description of the layer
+ }
+
+ class VkSubmitInfo {
+@@ -1273,7 +1273,7 @@ class VkSubmitInfo {
+ u32 waitSemaphoreCount
+ const VkSemaphore* pWaitSemaphores
+ u32 commandBufferCount
+- const VkCmdBuffer* pCommandBuffers
++ const VkCommandBuffer* pCommandBuffers
+ u32 signalSemaphoreCount
+ const VkSemaphore* pSignalSemaphores
+ }
+@@ -1281,19 +1281,19 @@ class VkSubmitInfo {
+ class VkApplicationInfo {
+ VkStructureType sType /// Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO
+ const void* pNext /// Next structure in chain
+- const char* pAppName
+- u32 appVersion
++ const char* pApplicationName
++ u32 applicationVersion
+ const char* pEngineName
+ u32 engineVersion
+ u32 apiVersion
+ }
+
+-class VkAllocCallbacks {
++class VkAllocationCallbacks {
+ void* pUserData
+- PFN_vkAllocFunction pfnAlloc
+- PFN_vkReallocFunction pfnRealloc
++ PFN_vkAllocationFunction pfnAllocation
++ PFN_vkReallocationFunction pfnReallocation
+ PFN_vkFreeFunction pfnFree
+- PFN_vkInternalAllocNotification pfnInternalAlloc
++ PFN_vkInternalAllocationNotification pfnInternalAllocation
+ PFN_vkInternalFreeNotification pfnInternalFree
+ }
+
+@@ -1323,7 +1323,7 @@ class VkInstanceCreateInfo {
+ VkStructureType sType /// Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+ VkInstanceCreateFlags flags
+- const VkApplicationInfo* pAppInfo
++ const VkApplicationInfo* pApplicationInfo
+ u32 enabledLayerNameCount
+ const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled
+ u32 enabledExtensionNameCount
+@@ -1343,7 +1343,7 @@ class VkPhysicalDeviceMemoryProperties {
+ VkMemoryHeap[VK_MAX_MEMORY_HEAPS] memoryHeaps
+ }
+
+-class VkMemoryAllocInfo {
++class VkMemoryAllocateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
+ const void* pNext /// Pointer to next structure
+ VkDeviceSize allocationSize /// Size of memory allocation
+@@ -1383,7 +1383,7 @@ class VkMemoryHeap {
+ class VkMappedMemoryRange {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
+ const void* pNext /// Pointer to next structure
+- VkDeviceMemory mem /// Mapped memory object
++ VkDeviceMemory memory /// Mapped memory object
+ VkDeviceSize offset /// Offset within the mapped memory the range starts from
+ VkDeviceSize size /// Size of the range within the mapped memory
+ }
+@@ -1417,9 +1417,9 @@ class VkDescriptorBufferInfo {
+ class VkWriteDescriptorSet {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
+ const void* pNext /// Pointer to next structure
+- VkDescriptorSet destSet /// Destination descriptor set
+- u32 destBinding /// Binding within the destination descriptor set to write
+- u32 destArrayElement /// Array element within the destination binding to write
++ VkDescriptorSet dstSet /// Destination descriptor set
++ u32 dstBinding /// Binding within the destination descriptor set to write
++ u32 dstArrayElement /// Array element within the destination binding to write
+ u32 descriptorCount /// Number of descriptors to write (determines the size of the array pointed by <pDescriptors>)
+ VkDescriptorType descriptorType /// Descriptor type to write (determines which fields of the array pointed by <pDescriptors> are going to be used)
+ const VkDescriptorImageInfo* pImageInfo
+@@ -1433,9 +1433,9 @@ class VkCopyDescriptorSet {
+ VkDescriptorSet srcSet /// Source descriptor set
+ u32 srcBinding /// Binding within the source descriptor set to copy from
+ u32 srcArrayElement /// Array element within the source binding to copy from
+- VkDescriptorSet destSet /// Destination descriptor set
+- u32 destBinding /// Binding within the destination descriptor set to copy to
+- u32 destArrayElement /// Array element within the destination binding to copy to
++ VkDescriptorSet dstSet /// Destination descriptor set
++ u32 dstBinding /// Binding within the destination descriptor set to copy to
++ u32 dstArrayElement /// Array element within the destination binding to copy to
+ u32 descriptorCount /// Number of descriptors to copy
+ }
+
+@@ -1469,9 +1469,9 @@ class VkImageSubresource {
+ class VkImageSubresourceRange {
+ VkImageAspectFlags aspectMask
+ u32 baseMipLevel
+- u32 numLevels
++ u32 levelCount
+ u32 baseArrayLayer
+- u32 numLayers
++ u32 layerCount
+ }
+
+ class VkMemoryBarrier {
+@@ -1487,7 +1487,7 @@ class VkBufferMemoryBarrier {
+ VkMemoryOutputFlags outputMask /// Outputs the barrier should sync
+ VkMemoryInputFlags inputMask /// Inputs the barrier should sync to
+ u32 srcQueueFamilyIndex /// Queue family to transition ownership from
+- u32 destQueueFamilyIndex /// Queue family to transition ownership to
++ u32 dstQueueFamilyIndex /// Queue family to transition ownership to
+ VkBuffer buffer /// Buffer to sync
+ VkDeviceSize offset /// Offset within the buffer to sync
+ VkDeviceSize size /// Amount of bytes to sync
+@@ -1501,7 +1501,7 @@ class VkImageMemoryBarrier {
+ VkImageLayout oldLayout /// Current layout of the image
+ VkImageLayout newLayout /// New layout to transition the image to
+ u32 srcQueueFamilyIndex /// Queue family to transition ownership from
+- u32 destQueueFamilyIndex /// Queue family to transition ownership to
++ u32 dstQueueFamilyIndex /// Queue family to transition ownership to
+ VkImage image /// Image to sync
+ VkImageSubresourceRange subresourceRange /// Subresource range to sync
+ }
+@@ -1544,15 +1544,15 @@ class VkImageViewCreateInfo {
+
+ class VkBufferCopy {
+ VkDeviceSize srcOffset /// Specified in bytes
+- VkDeviceSize destOffset /// Specified in bytes
++ VkDeviceSize dstOffset /// Specified in bytes
+ VkDeviceSize size /// Specified in bytes
+ }
+
+ class VkSparseMemoryBind {
+ VkDeviceSize resourceOffset /// Specified in bytes
+ VkDeviceSize size /// Specified in bytes
+- VkDeviceMemory mem
+- VkDeviceSize memOffset /// Specified in bytes
++ VkDeviceMemory memory
++ VkDeviceSize memoryOffset /// Specified in bytes
+ VkSparseMemoryBindFlags flags
+ }
+
+@@ -1560,8 +1560,8 @@ class VkSparseImageMemoryBind {
+ VkImageSubresource subresource
+ VkOffset3D offset
+ VkExtent3D extent
+- VkDeviceMemory mem
+- VkDeviceSize memOffset /// Specified in bytes
++ VkDeviceMemory memory
++ VkDeviceSize memoryOffset /// Specified in bytes
+ VkSparseMemoryBindFlags flags
+ }
+
+@@ -1602,14 +1602,14 @@ class VkImageSubresourceCopy {
+ VkImageAspectFlags aspect
+ u32 mipLevel
+ u32 baseArrayLayer
+- u32 numLayers
++ u32 layerCount
+ }
+
+ class VkImageCopy {
+ VkImageSubresourceCopy srcSubresource
+ VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images
+- VkImageSubresourceCopy destSubresource
+- VkOffset3D destOffset /// Specified in pixels for both compressed and uncompressed images
++ VkImageSubresourceCopy dstSubresource
++ VkOffset3D dstOffset /// Specified in pixels for both compressed and uncompressed images
+ VkExtent3D extent /// Specified in pixels for both compressed and uncompressed images
+ }
+
+@@ -1617,9 +1617,9 @@ class VkImageBlit {
+ VkImageSubresourceCopy srcSubresource
+ VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images
+ VkExtent3D srcExtent /// Specified in pixels for both compressed and uncompressed images
+- VkImageSubresourceCopy destSubresource
+- VkOffset3D destOffset /// Specified in pixels for both compressed and uncompressed images
+- VkExtent3D destExtent /// Specified in pixels for both compressed and uncompressed images
++ VkImageSubresourceCopy dstSubresource
++ VkOffset3D dstOffset /// Specified in pixels for both compressed and uncompressed images
++ VkExtent3D dstExtent /// Specified in pixels for both compressed and uncompressed images
+ }
+
+ class VkBufferImageCopy {
+@@ -1634,8 +1634,8 @@ class VkBufferImageCopy {
+ class VkImageResolve {
+ VkImageSubresourceCopy srcSubresource
+ VkOffset3D srcOffset
+- VkImageSubresourceCopy destSubresource
+- VkOffset3D destOffset
++ VkImageSubresourceCopy dstSubresource
++ VkOffset3D dstOffset
+ VkExtent3D extent
+ }
+
+@@ -1685,7 +1685,7 @@ class VkDescriptorPoolCreateInfo {
+ const VkDescriptorTypeCount* pTypeCounts
+ }
+
+-class VkDescriptorSetAllocInfo {
++class VkDescriptorSetAllocateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO
+ const void* pNext /// Pointer to next structure
+ VkDescriptorPool descriptorPool
+@@ -1772,10 +1772,10 @@ class VkPipelineViewportStateCreateInfo {
+ const VkRect2D* pScissors
+ }
+
+-class VkPipelineRasterStateCreateInfo {
++class VkPipelineRasterizationStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- VkPipelineRasterStateCreateFlags flags
++ VkPipelineRasterizationStateCreateFlags flags
+ VkBool32 depthClampEnable
+ VkBool32 rasterizerDiscardEnable
+ VkFillMode fillMode /// optional (GL45)
+@@ -1792,7 +1792,7 @@ class VkPipelineMultisampleStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+ VkPipelineMultisampleStateCreateFlags flags
+- u32 rasterSamples /// Number of samples used for rasterization
++ u32 rasterizationSamples /// Number of samples used for rasterization
+ VkBool32 sampleShadingEnable /// optional (GL45)
+ f32 minSampleShading /// optional (GL45)
+ const VkSampleMask* pSampleMask
+@@ -1803,10 +1803,10 @@ class VkPipelineMultisampleStateCreateInfo {
+ class VkPipelineColorBlendAttachmentState {
+ VkBool32 blendEnable
+ VkBlend srcBlendColor
+- VkBlend destBlendColor
++ VkBlend dstBlendColor
+ VkBlendOp blendOpColor
+ VkBlend srcBlendAlpha
+- VkBlend destBlendAlpha
++ VkBlend dstBlendAlpha
+ VkBlendOp blendOpAlpha
+ VkChannelFlags channelWriteMask
+ }
+@@ -1865,7 +1865,7 @@ class VkGraphicsPipelineCreateInfo {
+ const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState
+ const VkPipelineTessellationStateCreateInfo* pTessellationState
+ const VkPipelineViewportStateCreateInfo* pViewportState
+- const VkPipelineRasterStateCreateInfo* pRasterState
++ const VkPipelineRasterizationStateCreateInfo* pRasterizationState
+ const VkPipelineMultisampleStateCreateInfo* pMultisampleState
+ const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState
+ const VkPipelineColorBlendStateCreateInfo* pColorBlendState
+@@ -1883,7 +1883,6 @@ class VkPipelineCacheCreateInfo {
+ VkPipelineCacheCreateFlags flags
+ platform.size_t initialDataSize /// Size of initial data to populate cache, in bytes
+ const void* pInitialData /// Initial data to populate cache
+- platform.size_t maxSize /// Maximum size cache can grow to, in bytes. If zero, then the cache may grow without bound.
+ }
+
+ class VkPushConstantRange {
+@@ -1922,25 +1921,25 @@ class VkSamplerCreateInfo {
+ VkBool32 unnormalizedCoordinates
+ }
+
+-class VkCmdPoolCreateInfo {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO
++class VkCommandPoolCreateInfo {
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+- VkCmdPoolCreateFlags flags /// Command pool creation flags
++ VkCommandPoolCreateFlags flags /// Command pool creation flags
+ u32 queueFamilyIndex
+ }
+
+-class VkCmdBufferAllocInfo {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO
++class VkCommandBufferAllocateInfo {
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO
+ const void* pNext /// Pointer to next structure
+- VkCmdPool cmdPool
+- VkCmdBufferLevel level
++ VkCommandPool commandPool
++ VkCommandBufferLevel level
+ u32 bufferCount
+ }
+
+-class VkCmdBufferBeginInfo {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO
++class VkCommandBufferBeginInfo {
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
+ const void* pNext /// Pointer to next structure
+- VkCmdBufferUsageFlags flags /// Command buffer usage flags
++ VkCommandBufferUsageFlags flags /// Command buffer usage flags
+ VkRenderPass renderPass /// Render pass for secondary command buffers
+ u32 subpass
+ VkFramebuffer framebuffer /// Framebuffer for secondary command buffers
+@@ -2014,9 +2013,9 @@ class VkSubpassDescription {
+
+ class VkSubpassDependency {
+ u32 srcSubpass
+- u32 destSubpass
++ u32 dstSubpass
+ VkPipelineStageFlags srcStageMask
+- VkPipelineStageFlags destStageMask
++ VkPipelineStageFlags dstStageMask
+ VkMemoryOutputFlags outputMask
+ VkMemoryInputFlags inputMask
+ VkDependencyFlags dependencyFlags
+@@ -2054,7 +2053,7 @@ class VkPhysicalDeviceFeatures {
+ VkBool32 geometryShader /// geometry stage
+ VkBool32 tessellationShader /// tessellation control and evaluation stage
+ VkBool32 sampleRateShading /// per-sample shading and interpolation
+- VkBool32 dualSourceBlend /// blend operations which take two sources
++ VkBool32 dualSrcBlend /// blend operations which take two sources
+ VkBool32 logicOp /// logic operations
+ VkBool32 multiDrawIndirect /// multi draw indirect
+ VkBool32 depthClamp /// depth clamping
+@@ -2136,7 +2135,7 @@ class VkPhysicalDeviceLimits {
+ u32 maxVertexInputBindingStride /// max vertex input binding stride
+ u32 maxVertexOutputComponents /// max num of output components written by vertex shader
+ /// tessellation control stage limits
+- u32 maxTessellationGenLevel /// max level supported by tess primitive generator
++ u32 maxTessellationGenerationLevel /// max level supported by tess primitive generator
+ u32 maxTessellationPatchSize /// max patch size (vertices)
+ u32 maxTessellationControlPerVertexInputComponents /// max num of input components per-vertex in TCS
+ u32 maxTessellationControlPerVertexOutputComponents /// max num of output components per-vertex in TCS
+@@ -2153,7 +2152,7 @@ class VkPhysicalDeviceLimits {
+ /// fragment stage limits
+ u32 maxFragmentInputComponents /// max num of input compontents read in fragment stage
+ u32 maxFragmentOutputAttachments /// max num of output attachments written in fragment stage
+- u32 maxFragmentDualSourceAttachments /// max num of output attachments written when using dual source blending
++ u32 maxFragmentDualSrcAttachments /// max num of output attachments written when using dual source blending
+ u32 maxFragmentCombinedOutputResources /// max total num of storage buffers, storage images and output buffers
+ /// compute stage limits
+ u32 maxComputeSharedMemorySize /// max total storage size of work group local storage (bytes)
+@@ -2258,14 +2257,14 @@ class VkFramebufferCreateInfo {
+ u32 layers
+ }
+
+-class VkDrawIndirectCmd {
++class VkDrawIndirectCommand {
+ u32 vertexCount
+ u32 instanceCount
+ u32 firstVertex
+ u32 firstInstance
+ }
+
+-class VkDrawIndexedIndirectCmd {
++class VkDrawIndexedIndirectCommand {
+ u32 indexCount
+ u32 instanceCount
+ u32 firstIndex
+@@ -2273,7 +2272,7 @@ class VkDrawIndexedIndirectCmd {
+ u32 firstInstance
+ }
+
+-class VkDispatchIndirectCmd {
++class VkDispatchIndirectCommand {
+ u32 x
+ u32 y
+ u32 z
+@@ -2420,45 +2419,45 @@ class VkDisplayPresentInfoKHR {
+ @pfn cmd void vkVoidFunction() {
+ }
+
+-@external type void* PFN_vkAllocFunction
+-@pfn cmd void* vkAllocFunction(
++@external type void* PFN_vkAllocationFunction
++@pfn cmd void* vkAllocationFunction(
+ void* pUserData,
+ platform.size_t size,
+ platform.size_t alignment,
+- VkSystemAllocScope allocScope) {
++ VkSystemAllocationScope allocationScope) {
+ return ?
+ }
+
+-@external type void* PFN_vkReallocFunction
+-@pfn cmd void* vkReallocFunction(
++@external type void* PFN_vkReallocationFunction
++@pfn cmd void* vkReallocationFunction(
+ void* pUserData,
+ void* pOriginal,
+ platform.size_t size,
+ platform.size_t alignment,
+- VkSystemAllocScope allocScope) {
++ VkSystemAllocationScope allocationScope) {
+ return ?
+ }
+
+ @external type void* PFN_vkFreeFunction
+ @pfn cmd void vkFreeFunction(
+ void* pUserData,
+- void* pMem) {
++ void* pMemory) {
+ }
+
+-@external type void* PFN_vkInternalAllocNotification
+-@pfn cmd void vkInternalAllocNotification(
++@external type void* PFN_vkInternalAllocationNotification
++@pfn cmd void vkInternalAllocationNotification(
+ void* pUserData,
+ platform.size_t size,
+- VkInternalAllocType allocType,
+- VkSystemAllocScope allocScope) {
++ VkInternalAllocationType allocationType,
++ VkSystemAllocationScope allocationScope) {
+ }
+
+ @external type void* PFN_vkInternalFreeNotification
+ @pfn cmd void vkInternalFreeNotification(
+ void* pUserData,
+ platform.size_t size,
+- VkInternalAllocType allocType,
+- VkSystemAllocScope allocScope) {
++ VkInternalAllocationType allocationType,
++ VkSystemAllocationScope allocationScope) {
+ }
+
+ // Global functions
+@@ -2466,7 +2465,7 @@ class VkDisplayPresentInfoKHR {
+ @threadSafety("system")
+ cmd VkResult vkCreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)
+
+@@ -2483,7 +2482,7 @@ cmd VkResult vkCreateInstance(
+ @threadSafety("system")
+ cmd void vkDestroyInstance(
+ VkInstance instance,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ instanceObject := GetInstance(instance)
+
+ State.Instances[instance] = null
+@@ -2610,7 +2609,7 @@ cmd void vkGetPhysicalDeviceImageFormatProperties(
+ cmd VkResult vkCreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+@@ -2625,7 +2624,7 @@ cmd VkResult vkCreateDevice(
+ @threadSafety("system")
+ cmd void vkDestroyDevice(
+ VkDevice device,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+
+ State.Devices[device] = null
+@@ -2733,14 +2732,14 @@ cmd VkResult vkQueueSubmit(
+ assert(fenceObject.device == queueObject.device)
+ }
+
+- // cmdBuffers := pCmdBuffers[0:cmdBufferCount]
+- // for i in (0 .. cmdBufferCount) {
+- // cmdBuffer := cmdBuffers[i]
+- // cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- // assert(cmdBufferObject.device == queueObject.device)
++ // commandBuffers := pcommandBuffers[0:commandBufferCount]
++ // for i in (0 .. commandBufferCount) {
++ // commandBuffer := commandBuffers[i]
++ // commandBufferObject := GetCommandBuffer(commandBuffer)
++ // assert(commandBufferObject.device == queueObject.device)
+ //
+- // validate("QueueCheck", cmdBufferObject.queueFlags in queueObject.flags,
+- // "vkQueueSubmit: enqueued cmdBuffer requires missing queue capabilities.")
++ // validate("QueueCheck", commandBufferObject.queueFlags in queueObject.flags,
++ // "vkQueueSubmit: enqueued commandBuffer requires missing queue capabilities.")
+ // }
+
+ return ?
+@@ -2766,19 +2765,19 @@ cmd VkResult vkDeviceWaitIdle(
+ // Memory functions
+
+ @threadSafety("system")
+-cmd VkResult vkAllocMemory(
++cmd VkResult vkAllocateMemory(
+ VkDevice device,
+- const VkMemoryAllocInfo* pAllocInfo,
+- const VkAllocCallbacks* pAllocator,
+- VkDeviceMemory* pMem) {
+- assert(pAllocInfo.sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO)
++ const VkMemoryAllocateInfo* pAllocateInfo,
++ const VkAllocationCallbacks* pAllocator,
++ VkDeviceMemory* pMemory) {
++ assert(pAllocateInfo.sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO)
+ deviceObject := GetDevice(device)
+
+- mem := ?
+- pMem[0] = mem
+- State.DeviceMemories[mem] = new!DeviceMemoryObject(
++ memory := ?
++ pMemory[0] = memory
++ State.DeviceMemories[memory] = new!DeviceMemoryObject(
+ device: device,
+- allocationSize: pAllocInfo[0].allocationSize)
++ allocationSize: pAllocateInfo[0].allocationSize)
+
+ return ?
+ }
+@@ -2786,34 +2785,34 @@ cmd VkResult vkAllocMemory(
+ @threadSafety("system")
+ cmd void vkFreeMemory(
+ VkDevice device,
+- VkDeviceMemory mem,
+- const VkAllocCallbacks* pAllocator) {
++ VkDeviceMemory memory,
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+- memObject := GetDeviceMemory(mem)
+- assert(memObject.device == device)
++ memoryObject := GetDeviceMemory(memory)
++ assert(memoryObject.device == device)
+
+ // Check that no objects are still bound before freeing.
+- validate("MemoryCheck", len(memObject.boundObjects) == 0,
++ validate("MemoryCheck", len(memoryObject.boundObjects) == 0,
+ "vkFreeMemory: objects still bound")
+- validate("MemoryCheck", len(memObject.boundCommandBuffers) == 0,
+- "vkFreeMemory: cmdBuffers still bound")
+- State.DeviceMemories[mem] = null
++ validate("MemoryCheck", len(memoryObject.boundCommandBuffers) == 0,
++ "vkFreeMemory: commandBuffers still bound")
++ State.DeviceMemories[memory] = null
+ }
+
+ @threadSafety("app")
+ cmd VkResult vkMapMemory(
+ VkDevice device,
+- VkDeviceMemory mem,
++ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData) {
+ deviceObject := GetDevice(device)
+- memObject := GetDeviceMemory(mem)
+- assert(memObject.device == device)
++ memoryObject := GetDeviceMemory(memory)
++ assert(memoryObject.device == device)
+
+ assert(flags == as!VkMemoryMapFlags(0))
+- assert((offset + size) <= memObject.allocationSize)
++ assert((offset + size) <= memoryObject.allocationSize)
+
+ return ?
+ }
+@@ -2821,24 +2820,24 @@ cmd VkResult vkMapMemory(
+ @threadSafety("app")
+ cmd void vkUnmapMemory(
+ VkDevice device,
+- VkDeviceMemory mem) {
++ VkDeviceMemory memory) {
+ deviceObject := GetDevice(device)
+- memObject := GetDeviceMemory(mem)
+- assert(memObject.device == device)
++ memoryObject := GetDeviceMemory(memory)
++ assert(memoryObject.device == device)
+ }
+
+ cmd VkResult vkFlushMappedMemoryRanges(
+ VkDevice device,
+- u32 memRangeCount
+- const VkMappedMemoryRange* pMemRanges) {
++ u32 memoryRangeCount
++ const VkMappedMemoryRange* pMemoryRanges) {
+ deviceObject := GetDevice(device)
+
+- memRanges := pMemRanges[0:memRangeCount]
+- for i in (0 .. memRangeCount) {
+- memRange := memRanges[i]
+- memObject := GetDeviceMemory(memRange.mem)
+- assert(memObject.device == device)
+- assert((memRange.offset + memRange.size) <= memObject.allocationSize)
++ memoryRanges := pMemoryRanges[0:memoryRangeCount]
++ for i in (0 .. memoryRangeCount) {
++ memoryRange := memoryRanges[i]
++ memoryObject := GetDeviceMemory(memoryRange.memory)
++ assert(memoryObject.device == device)
++ assert((memoryRange.offset + memoryRange.size) <= memoryObject.allocationSize)
+ }
+
+ return ?
+@@ -2846,16 +2845,16 @@ cmd VkResult vkFlushMappedMemoryRanges(
+
+ cmd VkResult vkInvalidateMappedMemoryRanges(
+ VkDevice device,
+- u32 memRangeCount,
+- const VkMappedMemoryRange* pMemRanges) {
++ u32 memoryRangeCount,
++ const VkMappedMemoryRange* pMemoryRanges) {
+ deviceObject := GetDevice(device)
+
+- memRanges := pMemRanges[0:memRangeCount]
+- for i in (0 .. memRangeCount) {
+- memRange := memRanges[i]
+- memObject := GetDeviceMemory(memRange.mem)
+- assert(memObject.device == device)
+- assert((memRange.offset + memRange.size) <= memObject.allocationSize)
++ memoryRanges := pMemoryRanges[0:memoryRangeCount]
++ for i in (0 .. memoryRangeCount) {
++ memoryRange := memoryRanges[i]
++ memoryObject := GetDeviceMemory(memoryRange.memory)
++ assert(memoryObject.device == device)
++ assert((memoryRange.offset + memoryRange.size) <= memoryObject.allocationSize)
+ }
+
+ return ?
+@@ -2891,26 +2890,26 @@ cmd void vkGetBufferMemoryRequirements(
+ cmd VkResult vkBindBufferMemory(
+ VkDevice device,
+ VkBuffer buffer,
+- VkDeviceMemory mem,
+- VkDeviceSize memOffset) {
++ VkDeviceMemory memory,
++ VkDeviceSize memoryOffset) {
+ deviceObject := GetDevice(device)
+ bufferObject := GetBuffer(buffer)
+ assert(bufferObject.device == device)
+
+ // Unbind buffer from previous memory object, if not VK_NULL_HANDLE.
+- if bufferObject.mem != NULL_HANDLE {
+- memObject := GetDeviceMemory(bufferObject.mem)
+- memObject.boundObjects[as!u64(buffer)] = null
++ if bufferObject.memory != NULL_HANDLE {
++ memoryObject := GetDeviceMemory(bufferObject.memory)
++ memoryObject.boundObjects[as!u64(buffer)] = null
+ }
+
+ // Bind buffer to given memory object, if not VK_NULL_HANDLE.
+- if mem != NULL_HANDLE {
+- memObject := GetDeviceMemory(mem)
+- assert(memObject.device == device)
+- memObject.boundObjects[as!u64(buffer)] = memOffset
++ if memory != NULL_HANDLE {
++ memoryObject := GetDeviceMemory(memory)
++ assert(memoryObject.device == device)
++ memoryObject.boundObjects[as!u64(buffer)] = memoryOffset
+ }
+- bufferObject.mem = mem
+- bufferObject.memOffset = memOffset
++ bufferObject.memory = memory
++ bufferObject.memoryOffset = memoryOffset
+
+ return ?
+ }
+@@ -2927,26 +2926,26 @@ cmd void vkGetImageMemoryRequirements(
+ cmd VkResult vkBindImageMemory(
+ VkDevice device,
+ VkImage image,
+- VkDeviceMemory mem,
+- VkDeviceSize memOffset) {
++ VkDeviceMemory memory,
++ VkDeviceSize memoryOffset) {
+ deviceObject := GetDevice(device)
+ imageObject := GetImage(image)
+ assert(imageObject.device == device)
+
+ // Unbind image from previous memory object, if not VK_NULL_HANDLE.
+- if imageObject.mem != NULL_HANDLE {
+- memObject := GetDeviceMemory(imageObject.mem)
+- memObject.boundObjects[as!u64(image)] = null
++ if imageObject.memory != NULL_HANDLE {
++ memoryObject := GetDeviceMemory(imageObject.memory)
++ memoryObject.boundObjects[as!u64(image)] = null
+ }
+
+ // Bind image to given memory object, if not VK_NULL_HANDLE.
+- if mem != NULL_HANDLE {
+- memObject := GetDeviceMemory(mem)
+- assert(memObject.device == device)
+- memObject.boundObjects[as!u64(image)] = memOffset
++ if memory != NULL_HANDLE {
++ memoryObject := GetDeviceMemory(memory)
++ assert(memoryObject.device == device)
++ memoryObject.boundObjects[as!u64(image)] = memoryOffset
+ }
+- imageObject.mem = mem
+- imageObject.memOffset = memOffset
++ imageObject.memory = memory
++ imageObject.memoryOffset = memoryOffset
+
+ return ?
+ }
+@@ -2990,7 +2989,7 @@ cmd VkResult vkQueueBindSparse(
+ cmd VkResult vkCreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3007,7 +3006,7 @@ cmd VkResult vkCreateFence(
+ cmd void vkDestroyFence(
+ VkDevice device,
+ VkFence fence,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ fenceObject := GetFence(fence)
+ assert(fenceObject.device == device)
+@@ -3070,7 +3069,7 @@ cmd VkResult vkWaitForFences(
+ cmd VkResult vkCreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3086,7 +3085,7 @@ cmd VkResult vkCreateSemaphore(
+ cmd void vkDestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ semaphoreObject := GetSemaphore(semaphore)
+ assert(semaphoreObject.device == device)
+@@ -3101,7 +3100,7 @@ cmd void vkDestroySemaphore(
+ cmd VkResult vkCreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3117,7 +3116,7 @@ cmd VkResult vkCreateEvent(
+ cmd void vkDestroyEvent(
+ VkDevice device,
+ VkEvent event,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ eventObject := GetEvent(event)
+ assert(eventObject.device == device)
+@@ -3165,7 +3164,7 @@ cmd VkResult vkResetEvent(
+ cmd VkResult vkCreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3181,7 +3180,7 @@ cmd VkResult vkCreateQueryPool(
+ cmd void vkDestroyQueryPool(
+ VkDevice device,
+ VkQueryPool queryPool,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ queryPoolObject := GetQueryPool(queryPool)
+ assert(queryPoolObject.device == device)
+@@ -3214,7 +3213,7 @@ cmd VkResult vkGetQueryPoolResults(
+ cmd VkResult vkCreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3230,12 +3229,12 @@ cmd VkResult vkCreateBuffer(
+ cmd void vkDestroyBuffer(
+ VkDevice device,
+ VkBuffer buffer,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ bufferObject := GetBuffer(buffer)
+ assert(bufferObject.device == device)
+
+- assert(bufferObject.mem == 0)
++ assert(bufferObject.memory == 0)
+ State.Buffers[buffer] = null
+ }
+
+@@ -3246,7 +3245,7 @@ cmd void vkDestroyBuffer(
+ cmd VkResult vkCreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3265,7 +3264,7 @@ cmd VkResult vkCreateBufferView(
+ cmd void vkDestroyBufferView(
+ VkDevice device,
+ VkBufferView bufferView,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ bufferViewObject := GetBufferView(bufferView)
+ assert(bufferViewObject.device == device)
+@@ -3280,7 +3279,7 @@ cmd void vkDestroyBufferView(
+ cmd VkResult vkCreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3296,12 +3295,12 @@ cmd VkResult vkCreateImage(
+ cmd void vkDestroyImage(
+ VkDevice device,
+ VkImage image,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ imageObject := GetImage(image)
+ assert(imageObject.device == device)
+
+- assert(imageObject.mem == 0)
++ assert(imageObject.memory == 0)
+ State.Images[image] = null
+ }
+
+@@ -3322,7 +3321,7 @@ cmd void vkGetImageSubresourceLayout(
+ cmd VkResult vkCreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3341,7 +3340,7 @@ cmd VkResult vkCreateImageView(
+ cmd void vkDestroyImageView(
+ VkDevice device,
+ VkImageView imageView,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ imageViewObject := GetImageView(imageView)
+ assert(imageViewObject.device == device)
+@@ -3355,7 +3354,7 @@ cmd void vkDestroyImageView(
+ cmd VkResult vkCreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3370,7 +3369,7 @@ cmd VkResult vkCreateShaderModule(
+ cmd void vkDestroyShaderModule(
+ VkDevice device,
+ VkShaderModule shaderModule,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ shaderModuleObject := GetShaderModule(shaderModule)
+ assert(shaderModuleObject.device == device)
+@@ -3382,7 +3381,7 @@ cmd void vkDestroyShaderModule(
+ cmd VkResult vkCreateShader(
+ VkDevice device,
+ const VkShaderCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkShader* pShader) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3398,7 +3397,7 @@ cmd VkResult vkCreateShader(
+ cmd void vkDestroyShader(
+ VkDevice device,
+ VkShader shader,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ shaderObject := GetShader(shader)
+ assert(shaderObject.device == device)
+@@ -3412,7 +3411,7 @@ cmd void vkDestroyShader(
+ cmd VkResult vkCreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3427,7 +3426,7 @@ cmd VkResult vkCreatePipelineCache(
+ cmd void vkDestroyPipelineCache(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ pipelineCacheObject := GetPipelineCache(pipelineCache)
+ assert(pipelineCacheObject.device == device)
+@@ -3449,12 +3448,12 @@ cmd VkResult vkGetPipelineCacheData(
+
+ cmd VkResult vkMergePipelineCaches(
+ VkDevice device,
+- VkPipelineCache destCache,
++ VkPipelineCache dstCache,
+ u32 srcCacheCount,
+ const VkPipelineCache* pSrcCaches) {
+ deviceObject := GetDevice(device)
+- destCacheObject := GetPipelineCache(destCache)
+- assert(destCacheObject.device == device)
++ dstCacheObject := GetPipelineCache(dstCache)
++ assert(dstCacheObject.device == device)
+
+ srcCaches := pSrcCaches[0:srcCacheCount]
+ for i in (0 .. srcCacheCount) {
+@@ -3471,7 +3470,7 @@ cmd VkResult vkCreateGraphicsPipelines(
+ VkPipelineCache pipelineCache,
+ u32 createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
+ deviceObject := GetDevice(device)
+ if pipelineCache != NULL_HANDLE {
+@@ -3495,7 +3494,7 @@ cmd VkResult vkCreateComputePipelines(
+ VkPipelineCache pipelineCache,
+ u32 createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
+ deviceObject := GetDevice(device)
+ if pipelineCache != NULL_HANDLE {
+@@ -3518,7 +3517,7 @@ cmd VkResult vkCreateComputePipelines(
+ cmd void vkDestroyPipeline(
+ VkDevice device,
+ VkPipeline pipeline,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ pipelineObjects := GetPipeline(pipeline)
+ assert(pipelineObjects.device == device)
+@@ -3533,7 +3532,7 @@ cmd void vkDestroyPipeline(
+ cmd VkResult vkCreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3549,7 +3548,7 @@ cmd VkResult vkCreatePipelineLayout(
+ cmd void vkDestroyPipelineLayout(
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ pipelineLayoutObjects := GetPipelineLayout(pipelineLayout)
+ assert(pipelineLayoutObjects.device == device)
+@@ -3564,7 +3563,7 @@ cmd void vkDestroyPipelineLayout(
+ cmd VkResult vkCreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3580,7 +3579,7 @@ cmd VkResult vkCreateSampler(
+ cmd void vkDestroySampler(
+ VkDevice device,
+ VkSampler sampler,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ samplerObject := GetSampler(sampler)
+ assert(samplerObject.device == device)
+@@ -3595,7 +3594,7 @@ cmd void vkDestroySampler(
+ cmd VkResult vkCreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3611,7 +3610,7 @@ cmd VkResult vkCreateDescriptorSetLayout(
+ cmd void vkDestroyDescriptorSetLayout(
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ descriptorSetLayoutObject := GetDescriptorSetLayout(descriptorSetLayout)
+ assert(descriptorSetLayoutObject.device == device)
+@@ -3623,7 +3622,7 @@ cmd void vkDestroyDescriptorSetLayout(
+ cmd VkResult vkCreateDescriptorPool(
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3639,7 +3638,7 @@ cmd VkResult vkCreateDescriptorPool(
+ cmd void vkDestroyDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ descriptorPoolObject := GetDescriptorPool(descriptorPool)
+ assert(descriptorPoolObject.device == device)
+@@ -3660,12 +3659,12 @@ cmd VkResult vkResetDescriptorPool(
+ }
+
+ @threadSafety("app")
+-cmd VkResult vkAllocDescriptorSets(
++cmd VkResult vkAllocateDescriptorSets(
+ VkDevice device,
+- const VkDescriptorSetAllocInfo* pAllocInfo,
++ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets) {
+ deviceObject := GetDevice(device)
+- allocInfo := pAllocInfo[0]
++ allocInfo := pAllocateInfo[0]
+ descriptorPoolObject := GetDescriptorPool(allocInfo.descriptorPool)
+
+ setLayouts := allocInfo.pSetLayouts[0:allocInfo.setCount]
+@@ -3715,14 +3714,14 @@ cmd void vkUpdateDescriptorSets(
+ descriptorWrites := pDescriptorWrites[0:descriptorWriteCount]
+ for i in (0 .. descriptorWriteCount) {
+ descriptorWrite := descriptorWrites[i]
+- descriptorWriteObject := GetDescriptorSet(descriptorWrite.destSet)
++ descriptorWriteObject := GetDescriptorSet(descriptorWrite.dstSet)
+ assert(descriptorWriteObject.device == device)
+ }
+
+ descriptorCopies := pDescriptorCopies[0:descriptorCopyCount]
+ for i in (0 .. descriptorCopyCount) {
+ descriptorCopy := descriptorCopies[i]
+- descriptorCopyObject := GetDescriptorSet(descriptorCopy.destSet)
++ descriptorCopyObject := GetDescriptorSet(descriptorCopy.dstSet)
+ assert(descriptorCopyObject.device == device)
+ }
+ }
+@@ -3734,7 +3733,7 @@ cmd void vkUpdateDescriptorSets(
+ cmd VkResult vkCreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3750,7 +3749,7 @@ cmd VkResult vkCreateFramebuffer(
+ cmd void vkDestroyFramebuffer(
+ VkDevice device,
+ VkFramebuffer framebuffer,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ framebufferObject := GetFramebuffer(framebuffer)
+ assert(framebufferObject.device == device)
+@@ -3765,7 +3764,7 @@ cmd void vkDestroyFramebuffer(
+ cmd VkResult vkCreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO)
+ deviceObject := GetDevice(device)
+@@ -3781,7 +3780,7 @@ cmd VkResult vkCreateRenderPass(
+ cmd void vkDestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass,
+- const VkAllocCallbacks* pAllocator) {
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ renderPassObject := GetRenderPass(renderPass)
+ assert(renderPassObject.device == device)
+@@ -3804,72 +3803,72 @@ cmd void vkGetRenderAreaGranularity(
+
+ cmd VkResult vkCreateCommandPool(
+ VkDevice device,
+- const VkCmdPoolCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
+- VkCmdPool* pCmdPool) {
+- assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO)
++ const VkCommandPoolCreateInfo* pCreateInfo,
++ const VkAllocationCallbacks* pAllocator,
++ VkCommandPool* pCommandPool) {
++ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO)
+ deviceObject := GetDevice(device)
+
+- cmdPool := ?
+- pCmdPool[0] = cmdPool
+- State.CmdPools[cmdPool] = new!CmdPoolObject(device: device)
++ commandPool := ?
++ pCommandPool[0] = commandPool
++ State.CommandPools[commandPool] = new!CommandPoolObject(device: device)
+
+ return ?
+ }
+
+ cmd void vkDestroyCommandPool(
+ VkDevice device,
+- VkCmdPool cmdPool,
+- const VkAllocCallbacks* pAllocator) {
++ VkCommandPool commandPool,
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+- cmdPoolObject := GetCmdPool(cmdPool)
+- assert(cmdPoolObject.device == device)
++ commandPoolObject := GetCommandPool(commandPool)
++ assert(commandPoolObject.device == device)
+
+- State.CmdPools[cmdPool] = null
++ State.CommandPools[commandPool] = null
+ }
+
+ cmd VkResult vkResetCommandPool(
+ VkDevice device,
+- VkCmdPool cmdPool,
+- VkCmdPoolResetFlags flags) {
++ VkCommandPool commandPool,
++ VkCommandPoolResetFlags flags) {
+ deviceObject := GetDevice(device)
+- cmdPoolObject := GetCmdPool(cmdPool)
+- assert(cmdPoolObject.device == device)
++ commandPoolObject := GetCommandPool(commandPool)
++ assert(commandPoolObject.device == device)
+
+ return ?
+ }
+
+ // Command buffer functions
+
+-macro void bindCmdBuffer(VkCmdBuffer cmdBuffer, any obj, VkDeviceMemory mem) {
+- memoryObject := GetDeviceMemory(mem)
+- memoryObject.boundCommandBuffers[cmdBuffer] = cmdBuffer
++macro void bindCommandBuffer(VkCommandBuffer commandBuffer, any obj, VkDeviceMemory memory) {
++ memoryObject := GetDeviceMemory(memory)
++ memoryObject.boundCommandBuffers[commandBuffer] = commandBuffer
+
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- cmdBufferObject.boundObjects[as!u64(obj)] = mem
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ commandBufferObject.boundObjects[as!u64(obj)] = memory
+ }
+
+-macro void unbindCmdBuffer(VkCmdBuffer cmdBuffer, any obj, VkDeviceMemory mem) {
+- memoryObject := GetDeviceMemory(mem)
+- memoryObject.boundCommandBuffers[cmdBuffer] = null
++macro void unbindCommandBuffer(VkCommandBuffer commandBuffer, any obj, VkDeviceMemory memory) {
++ memoryObject := GetDeviceMemory(memory)
++ memoryObject.boundCommandBuffers[commandBuffer] = null
+
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- cmdBufferObject.boundObjects[as!u64(obj)] = null
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ commandBufferObject.boundObjects[as!u64(obj)] = null
+ }
+
+ @threadSafety("system")
+-cmd VkResult vkAllocCommandBuffers(
++cmd VkResult vkAllocateCommandBuffers(
+ VkDevice device,
+- const VkCmdBufferAllocInfo* pAllocInfo,
+- VkCmdBuffer* pCmdBuffers) {
+- assert(pAllocInfo[0].sType == VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO)
++ const VkCommandBufferAllocateInfo* pAllocateInfo,
++ VkCommandBuffer* pCommandBuffers) {
++ assert(pAllocateInfo[0].sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO)
+
+- count := pAllocInfo[0].bufferCount
+- cmdBuffers := pCmdBuffers[0:count]
++ count := pAllocateInfo[0].bufferCount
++ commandBuffers := pCommandBuffers[0:count]
+ for i in (0 .. count) {
+- cmdBuffer := ?
+- cmdBuffers[i] = cmdBuffer
+- State.CmdBuffers[cmdBuffer] = new!CmdBufferObject(device: device)
++ commandBuffer := ?
++ commandBuffers[i] = commandBuffer
++ State.CommandBuffers[commandBuffer] = new!CommandBufferObject(device: device)
+ }
+
+ return ?
+@@ -3878,26 +3877,26 @@ cmd VkResult vkAllocCommandBuffers(
+ @threadSafety("system")
+ cmd void vkFreeCommandBuffers(
+ VkDevice device,
+- VkCmdPool cmdPool,
++ VkCommandPool commandPool,
+ u32 commandBufferCount,
+- const VkCmdBuffer* pCommandBuffers) {
++ const VkCommandBuffer* pCommandBuffers) {
+ deviceObject := GetDevice(device)
+
+- cmdBuffers := pCommandBuffers[0:commandBufferCount]
++ commandBuffers := pCommandBuffers[0:commandBufferCount]
+ for i in (0 .. commandBufferCount) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffers[i])
+- assert(cmdBufferObject.device == device)
++ commandBufferObject := GetCommandBuffer(commandBuffers[i])
++ assert(commandBufferObject.device == device)
+ // TODO: iterate over boundObjects and clear memory bindings
+- State.CmdBuffers[cmdBuffers[i]] = null
++ State.CommandBuffers[commandBuffers[i]] = null
+ }
+ }
+
+ @threadSafety("app")
+ cmd VkResult vkBeginCommandBuffer(
+- VkCmdBuffer cmdBuffer,
+- const VkCmdBufferBeginInfo* pBeginInfo) {
+- assert(pBeginInfo.sType == VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO)
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ VkCommandBuffer commandBuffer,
++ const VkCommandBufferBeginInfo* pBeginInfo) {
++ assert(pBeginInfo.sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+ // TODO: iterate over boundObjects and clear memory bindings
+
+@@ -3906,17 +3905,17 @@ cmd VkResult vkBeginCommandBuffer(
+
+ @threadSafety("app")
+ cmd VkResult vkEndCommandBuffer(
+- VkCmdBuffer cmdBuffer) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ VkCommandBuffer commandBuffer) {
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+ return ?
+ }
+
+ @threadSafety("app")
+ cmd VkResult vkResetCommandBuffer(
+- VkCmdBuffer cmdBuffer,
+- VkCmdBufferResetFlags flags) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ VkCommandBuffer commandBuffer,
++ VkCommandBufferResetFlags flags) {
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+ // TODO: iterate over boundObjects and clear memory bindings
+
+@@ -3928,106 +3927,106 @@ cmd VkResult vkResetCommandBuffer(
+
+ @threadSafety("app")
+ cmd void vkCmdBindPipeline(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ pipelineObject := GetPipeline(pipeline)
+- assert(cmdBufferObject.device == pipelineObject.device)
++ assert(commandBufferObject.device == pipelineObject.device)
+
+ queue := switch (pipelineBindPoint) {
+ case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT
+ case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
+ }
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, queue)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, queue)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdSetViewport(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ u32 viewportCount,
+ const VkViewport* pViewports) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdSetScissor(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ u32 scissorCount,
+ const VkRect2D* pScissors) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdSetLineWidth(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ f32 lineWidth) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdSetDepthBias(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ f32 depthBiasConstantFactor,
+ f32 depthBiasClamp,
+ f32 depthBiasSlopeFactor) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdSetBlendConstants(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ // TODO(jessehall): apic only supports 'const' on pointer types. Using
+ // an annotation as a quick hack to pass this to the template without
+ // having to modify the AST and semantic model.
+ @readonly f32[4] blendConstants) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdSetDepthBounds(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ f32 minDepthBounds,
+ f32 maxDepthBounds) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdSetStencilCompareMask(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ u32 stencilCompareMask) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdSetStencilWriteMask(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ u32 stencilWriteMask) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdSetStencilReference(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ u32 stencilReference) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdBindDescriptorSets(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ u32 firstSet,
+@@ -4035,13 +4034,13 @@ cmd void vkCmdBindDescriptorSets(
+ const VkDescriptorSet* pDescriptorSets,
+ u32 dynamicOffsetCount,
+ const u32* pDynamicOffsets) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+ descriptorSets := pDescriptorSets[0:descriptorSetCount]
+ for i in (0 .. descriptorSetCount) {
+ descriptorSet := descriptorSets[i]
+ descriptorSetObject := GetDescriptorSet(descriptorSet)
+- assert(cmdBufferObject.device == descriptorSetObject.device)
++ assert(commandBufferObject.device == descriptorSetObject.device)
+ }
+
+ dynamicOffsets := pDynamicOffsets[0:dynamicOffsetCount]
+@@ -4053,32 +4052,32 @@ cmd void vkCmdBindDescriptorSets(
+ case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT
+ case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
+ }
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, queue)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, queue)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdBindIndexBuffer(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ bufferObject := GetBuffer(buffer)
+- assert(cmdBufferObject.device == bufferObject.device)
++ assert(commandBufferObject.device == bufferObject.device)
+
+- bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
++ bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdBindVertexBuffers(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ u32 startBinding,
+ u32 bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+ // TODO: check if not [startBinding:startBinding+bindingCount]
+ buffers := pBuffers[0:bindingCount]
+@@ -4087,395 +4086,395 @@ cmd void vkCmdBindVertexBuffers(
+ buffer := buffers[i]
+ offset := offsets[i]
+ bufferObject := GetBuffer(buffer)
+- assert(cmdBufferObject.device == bufferObject.device)
++ assert(commandBufferObject.device == bufferObject.device)
+
+- bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
++ bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
+ }
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdDraw(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ u32 vertexCount,
+ u32 instanceCount,
+ u32 firstVertex,
+ u32 firstInstance) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdDrawIndexed(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ u32 indexCount,
+ u32 instanceCount,
+ u32 firstIndex,
+ s32 vertexOffset,
+ u32 firstInstance) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdDrawIndirect(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ u32 drawCount,
+ u32 stride) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ bufferObject := GetBuffer(buffer)
+- assert(cmdBufferObject.device == bufferObject.device)
++ assert(commandBufferObject.device == bufferObject.device)
+
+- bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
++ bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdDrawIndexedIndirect(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ u32 drawCount,
+ u32 stride) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ bufferObject := GetBuffer(buffer)
+- assert(cmdBufferObject.device == bufferObject.device)
++ assert(commandBufferObject.device == bufferObject.device)
+
+- bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
++ bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdDispatch(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ u32 x,
+ u32 y,
+ u32 z) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdDispatchIndirect(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ bufferObject := GetBuffer(buffer)
+- assert(cmdBufferObject.device == bufferObject.device)
++ assert(commandBufferObject.device == bufferObject.device)
+
+- bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
++ bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdCopyBuffer(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+- VkBuffer destBuffer,
++ VkBuffer dstBuffer,
+ u32 regionCount,
+ const VkBufferCopy* pRegions) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ srcBufferObject := GetBuffer(srcBuffer)
+- destBufferObject := GetBuffer(destBuffer)
+- assert(cmdBufferObject.device == srcBufferObject.device)
+- assert(cmdBufferObject.device == destBufferObject.device)
++ dstBufferObject := GetBuffer(dstBuffer)
++ assert(commandBufferObject.device == srcBufferObject.device)
++ assert(commandBufferObject.device == dstBufferObject.device)
+
+ regions := pRegions[0:regionCount]
+ for i in (0 .. regionCount) {
+ region := regions[i]
+ }
+
+- bindCmdBuffer(cmdBuffer, srcBuffer, srcBufferObject.mem)
+- bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
++ bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
++ bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdCopyImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+- VkImage destImage,
+- VkImageLayout destImageLayout,
++ VkImage dstImage,
++ VkImageLayout dstImageLayout,
+ u32 regionCount,
+ const VkImageCopy* pRegions) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ srcImageObject := GetImage(srcImage)
+- destImageObject := GetImage(destImage)
+- assert(cmdBufferObject.device == srcImageObject.device)
+- assert(cmdBufferObject.device == destImageObject.device)
++ dstImageObject := GetImage(dstImage)
++ assert(commandBufferObject.device == srcImageObject.device)
++ assert(commandBufferObject.device == dstImageObject.device)
+
+ regions := pRegions[0:regionCount]
+ for i in (0 .. regionCount) {
+ region := regions[i]
+ }
+
+- bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
+- bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
++ bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
++ bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdBlitImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+- VkImage destImage,
+- VkImageLayout destImageLayout,
++ VkImage dstImage,
++ VkImageLayout dstImageLayout,
+ u32 regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ srcImageObject := GetImage(srcImage)
+- destImageObject := GetImage(destImage)
+- assert(cmdBufferObject.device == srcImageObject.device)
+- assert(cmdBufferObject.device == destImageObject.device)
++ dstImageObject := GetImage(dstImage)
++ assert(commandBufferObject.device == srcImageObject.device)
++ assert(commandBufferObject.device == dstImageObject.device)
+
+ regions := pRegions[0:regionCount]
+ for i in (0 .. regionCount) {
+ region := regions[i]
+ }
+
+- bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
+- bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
++ bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
++ bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdCopyBufferToImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+- VkImage destImage,
+- VkImageLayout destImageLayout,
++ VkImage dstImage,
++ VkImageLayout dstImageLayout,
+ u32 regionCount,
+ const VkBufferImageCopy* pRegions) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ srcBufferObject := GetBuffer(srcBuffer)
+- destImageObject := GetImage(destImage)
+- assert(cmdBufferObject.device == srcBufferObject.device)
+- assert(cmdBufferObject.device == destImageObject.device)
++ dstImageObject := GetImage(dstImage)
++ assert(commandBufferObject.device == srcBufferObject.device)
++ assert(commandBufferObject.device == dstImageObject.device)
+
+ regions := pRegions[0:regionCount]
+ for i in (0 .. regionCount) {
+ region := regions[i]
+ }
+
+- bindCmdBuffer(cmdBuffer, srcBuffer, srcBufferObject.mem)
+- bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
++ bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
++ bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdCopyImageToBuffer(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+- VkBuffer destBuffer,
++ VkBuffer dstBuffer,
+ u32 regionCount,
+ const VkBufferImageCopy* pRegions) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ srcImageObject := GetImage(srcImage)
+- destBufferObject := GetBuffer(destBuffer)
+- assert(cmdBufferObject.device == srcImageObject.device)
+- assert(cmdBufferObject.device == destBufferObject.device)
++ dstBufferObject := GetBuffer(dstBuffer)
++ assert(commandBufferObject.device == srcImageObject.device)
++ assert(commandBufferObject.device == dstBufferObject.device)
+
+ regions := pRegions[0:regionCount]
+ for i in (0 .. regionCount) {
+ region := regions[i]
+ }
+
+- bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
+- bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
++ bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
++ bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdUpdateBuffer(
+- VkCmdBuffer cmdBuffer,
+- VkBuffer destBuffer,
+- VkDeviceSize destOffset,
++ VkCommandBuffer commandBuffer,
++ VkBuffer dstBuffer,
++ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const u32* pData) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- destBufferObject := GetBuffer(destBuffer)
+- assert(cmdBufferObject.device == destBufferObject.device)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ dstBufferObject := GetBuffer(dstBuffer)
++ assert(commandBufferObject.device == dstBufferObject.device)
+
+ data := pData[0:dataSize]
+
+- bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
++ bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdFillBuffer(
+- VkCmdBuffer cmdBuffer,
+- VkBuffer destBuffer,
+- VkDeviceSize destOffset,
++ VkCommandBuffer commandBuffer,
++ VkBuffer dstBuffer,
++ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ u32 data) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+- destBufferObject := GetBuffer(destBuffer)
+- assert(cmdBufferObject.device == destBufferObject.device)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++ dstBufferObject := GetBuffer(dstBuffer)
++ assert(commandBufferObject.device == dstBufferObject.device)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdClearColorImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+ u32 rangeCount,
+ const VkImageSubresourceRange* pRanges) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ imageObject := GetImage(image)
+- assert(cmdBufferObject.device == imageObject.device)
++ assert(commandBufferObject.device == imageObject.device)
+
+ ranges := pRanges[0:rangeCount]
+ for i in (0 .. rangeCount) {
+ range := ranges[i]
+ }
+
+- bindCmdBuffer(cmdBuffer, image, imageObject.mem)
++ bindCommandBuffer(commandBuffer, image, imageObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdClearDepthStencilImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ u32 rangeCount,
+ const VkImageSubresourceRange* pRanges) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ imageObject := GetImage(image)
+- assert(cmdBufferObject.device == imageObject.device)
++ assert(commandBufferObject.device == imageObject.device)
+
+ ranges := pRanges[0:rangeCount]
+ for i in (0 .. rangeCount) {
+ range := ranges[i]
+ }
+
+- bindCmdBuffer(cmdBuffer, image, imageObject.mem)
++ bindCommandBuffer(commandBuffer, image, imageObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdClearAttachments(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ u32 attachmentCount,
+ const VkClearAttachment* pAttachments,
+ u32 rectCount,
+ const VkClearRect* pRects) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+ rects := pRects[0:rectCount]
+ for i in (0 .. rectCount) {
+ rect := rects[i]
+ }
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdResolveImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+- VkImage destImage,
+- VkImageLayout destImageLayout,
++ VkImage dstImage,
++ VkImageLayout dstImageLayout,
+ u32 regionCount,
+ const VkImageResolve* pRegions) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ srcImageObject := GetImage(srcImage)
+- destImageObject := GetImage(destImage)
+- assert(cmdBufferObject.device == srcImageObject.device)
+- assert(cmdBufferObject.device == destImageObject.device)
++ dstImageObject := GetImage(dstImage)
++ assert(commandBufferObject.device == srcImageObject.device)
++ assert(commandBufferObject.device == dstImageObject.device)
+
+ regions := pRegions[0:regionCount]
+ for i in (0 .. regionCount) {
+ region := regions[i]
+ }
+
+- bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
+- bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
++ bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
++ bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdSetEvent(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ eventObject := GetEvent(event)
+- assert(cmdBufferObject.device == eventObject.device)
++ assert(commandBufferObject.device == eventObject.device)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdResetEvent(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ eventObject := GetEvent(event)
+- assert(cmdBufferObject.device == eventObject.device)
++ assert(commandBufferObject.device == eventObject.device)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdWaitEvents(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ u32 eventCount,
+ const VkEvent* pEvents,
+ VkPipelineStageFlags srcStageMask,
+- VkPipelineStageFlags destStageMask,
+- u32 memBarrierCount,
+- const void* const* ppMemBarriers) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ VkPipelineStageFlags dstStageMask,
++ u32 memoryBarrierCount,
++ const void* const* ppMemoryBarriers) {
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+ events := pEvents[0:eventCount]
+ for i in (0 .. eventCount) {
+ event := events[i]
+ eventObject := GetEvent(event)
+- assert(cmdBufferObject.device == eventObject.device)
++ assert(commandBufferObject.device == eventObject.device)
+ }
+
+- pMemBarriers := ppMemBarriers[0:memBarrierCount]
+- for i in (0 .. memBarrierCount) {
+- switch as!VkMemoryBarrier const*(pMemBarriers[i])[0].sType {
++ pMemoryBarriers := ppMemoryBarriers[0:memoryBarrierCount]
++ for i in (0 .. memoryBarrierCount) {
++ switch as!VkMemoryBarrier const*(pMemoryBarriers[i])[0].sType {
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER: {
+- memBarrier := as!VkMemoryBarrier const*(pMemBarriers[i])[0]
++ memoryBarrier := as!VkMemoryBarrier const*(pMemoryBarriers[i])[0]
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: {
+- imageMemBarrier := as!VkImageMemoryBarrier const*(pMemBarriers[i])[0]
+- imageObject := GetImage(imageMemBarrier.image)
+- assert(imageObject.device == cmdBufferObject.device)
++ imageMemoryBarrier := as!VkImageMemoryBarrier const*(pMemoryBarriers[i])[0]
++ imageObject := GetImage(imageMemoryBarrier.image)
++ assert(imageObject.device == commandBufferObject.device)
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: {
+- bufferMemBarrier := as!VkBufferMemoryBarrier const*(pMemBarriers[i])[0]
+- bufferObject := GetBuffer(bufferMemBarrier.buffer)
+- assert(bufferObject.device == cmdBufferObject.device)
++ bufferMemoryBarrier := as!VkBufferMemoryBarrier const*(pMemoryBarriers[i])[0]
++ bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
++ assert(bufferObject.device == commandBufferObject.device)
+ }
+ }
+ }
+@@ -4483,29 +4482,29 @@ cmd void vkCmdWaitEvents(
+
+ @threadSafety("app")
+ cmd void vkCmdPipelineBarrier(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+- VkPipelineStageFlags destStageMask,
++ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+- u32 memBarrierCount,
+- const void* const* ppMemBarriers) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ u32 memoryBarrierCount,
++ const void* const* ppMemoryBarriers) {
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+- pMemBarriers := ppMemBarriers[0:memBarrierCount]
+- for i in (0 .. memBarrierCount) {
+- switch as!VkMemoryBarrier const*(pMemBarriers[i])[0].sType {
++ pMemoryBarriers := ppMemoryBarriers[0:memoryBarrierCount]
++ for i in (0 .. memoryBarrierCount) {
++ switch as!VkMemoryBarrier const*(pMemoryBarriers[i])[0].sType {
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER: {
+- memBarrier := as!VkMemoryBarrier const*(pMemBarriers[i])[0]
++ memoryBarrier := as!VkMemoryBarrier const*(pMemoryBarriers[i])[0]
+ }
+ case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: {
+- imageMemBarrier := as!VkImageMemoryBarrier const*(pMemBarriers[i])[0]
+- imageObject := GetImage(imageMemBarrier.image)
+- assert(imageObject.device == cmdBufferObject.device)
++ imageMemoryBarrier := as!VkImageMemoryBarrier const*(pMemoryBarriers[i])[0]
++ imageObject := GetImage(imageMemoryBarrier.image)
++ assert(imageObject.device == commandBufferObject.device)
+ }
+ case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: {
+- bufferMemBarrier := as!VkBufferMemoryBarrier const*(pMemBarriers[i])[0]
+- bufferObject := GetBuffer(bufferMemBarrier.buffer)
+- assert(bufferObject.device == cmdBufferObject.device)
++ bufferMemoryBarrier := as!VkBufferMemoryBarrier const*(pMemoryBarriers[i])[0]
++ bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
++ assert(bufferObject.device == commandBufferObject.device)
+ }
+ }
+ }
+@@ -4513,115 +4512,115 @@ cmd void vkCmdPipelineBarrier(
+
+ @threadSafety("app")
+ cmd void vkCmdBeginQuery(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ u32 slot,
+ VkQueryControlFlags flags) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ queryPoolObject := GetQueryPool(queryPool)
+- assert(cmdBufferObject.device == queryPoolObject.device)
++ assert(commandBufferObject.device == queryPoolObject.device)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdEndQuery(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ u32 slot) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ queryPoolObject := GetQueryPool(queryPool)
+- assert(cmdBufferObject.device == queryPoolObject.device)
++ assert(commandBufferObject.device == queryPoolObject.device)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdResetQueryPool(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ u32 startQuery,
+ u32 queryCount) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ queryPoolObject := GetQueryPool(queryPool)
+- assert(cmdBufferObject.device == queryPoolObject.device)
++ assert(commandBufferObject.device == queryPoolObject.device)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdWriteTimestamp(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ u32 slot) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ queryPoolObject := GetQueryPool(queryPool)
+- assert(cmdBufferObject.device == queryPoolObject.device)
++ assert(commandBufferObject.device == queryPoolObject.device)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdCopyQueryPoolResults(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ u32 startQuery,
+ u32 queryCount,
+- VkBuffer destBuffer,
+- VkDeviceSize destOffset,
++ VkBuffer dstBuffer,
++ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ queryPoolObject := GetQueryPool(queryPool)
+- destBufferObject := GetBuffer(destBuffer)
+- assert(cmdBufferObject.device == queryPoolObject.device)
+- assert(cmdBufferObject.device == destBufferObject.device)
++ dstBufferObject := GetBuffer(dstBuffer)
++ assert(commandBufferObject.device == queryPoolObject.device)
++ assert(commandBufferObject.device == dstBufferObject.device)
+ }
+
+ cmd void vkCmdPushConstants(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ u32 offset,
+ u32 size,
+ const void* values) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ layoutObject := GetPipelineLayout(layout)
+- assert(cmdBufferObject.device == layoutObject.device)
++ assert(commandBufferObject.device == layoutObject.device)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdBeginRenderPass(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkRenderPassContents contents) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ renderPassObject := GetRenderPass(pRenderPassBegin.renderPass)
+ framebufferObject := GetFramebuffer(pRenderPassBegin.framebuffer)
+- assert(cmdBufferObject.device == renderPassObject.device)
+- assert(cmdBufferObject.device == framebufferObject.device)
++ assert(commandBufferObject.device == renderPassObject.device)
++ assert(commandBufferObject.device == framebufferObject.device)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ cmd void vkCmdNextSubpass(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkRenderPassContents contents) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+ }
+
+ @threadSafety("app")
+ cmd void vkCmdEndRenderPass(
+- VkCmdBuffer cmdBuffer) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
++ VkCommandBuffer commandBuffer) {
++ commandBufferObject := GetCommandBuffer(commandBuffer)
+
+- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ cmd void vkCmdExecuteCommands(
+- VkCmdBuffer cmdBuffer,
+- u32 cmdBuffersCount,
+- const VkCmdBuffer* pCmdBuffers) {
+- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+-
+- cmdBuffers := pCmdBuffers[0:cmdBuffersCount]
+- for i in (0 .. cmdBuffersCount) {
+- secondaryCmdBuffer := cmdBuffers[i]
+- secondaryCmdBufferObject := GetCmdBuffer(secondaryCmdBuffer)
+- assert(cmdBufferObject.device == secondaryCmdBufferObject.device)
++ VkCommandBuffer commandBuffer,
++ u32 commandBuffersCount,
++ const VkCommandBuffer* pCommandBuffers) {
++ commandBufferObject := GetCommandBuffer(commandBuffer)
++
++ commandBuffers := pCommandBuffers[0:commandBuffersCount]
++ for i in (0 .. commandBuffersCount) {
++ secondaryCommandBuffer := commandBuffers[i]
++ secondaryCommandBufferObject := GetCommandBuffer(secondaryCommandBuffer)
++ assert(commandBufferObject.device == secondaryCommandBufferObject.device)
+ }
+ }
+
+@@ -4966,7 +4965,7 @@ StateObject State
+ map!(VkPhysicalDevice, ref!PhysicalDeviceObject) PhysicalDevices
+ map!(VkDevice, ref!DeviceObject) Devices
+ map!(VkQueue, ref!QueueObject) Queues
+- map!(VkCmdBuffer, ref!CmdBufferObject) CmdBuffers
++ map!(VkCommandBuffer, ref!CommandBufferObject) CommandBuffers
+
+ // Non-dispatchable objects.
+ map!(VkDeviceMemory, ref!DeviceMemoryObject) DeviceMemories
+@@ -4989,7 +4988,7 @@ StateObject State
+ map!(VkFramebuffer, ref!FramebufferObject) Framebuffers
+ map!(VkRenderPass, ref!RenderPassObject) RenderPasses
+ map!(VkPipelineCache, ref!PipelineCacheObject) PipelineCaches
+- map!(VkCmdPool, ref!CmdPoolObject) CmdPools
++ map!(VkCommandPool, ref!CommandPoolObject) CommandPools
+ map!(VkSurfaceKHR, ref!SurfaceObject) Surfaces
+ map!(VkSwapchainKHR, ref!SwapchainObject) Swapchains
+ }
+@@ -5010,23 +5009,23 @@ StateObject State
+ VkQueueFlags flags
+ }
+
+-@internal class CmdBufferObject {
++@internal class CommandBufferObject {
+ VkDevice device
+ map!(u64, VkDeviceMemory) boundObjects
+ VkQueueFlags queueFlags
+ }
+
+ @internal class DeviceMemoryObject {
+- VkDevice device
+- VkDeviceSize allocationSize
+- map!(u64, VkDeviceSize ) boundObjects
+- map!(VkCmdBuffer, VkCmdBuffer) boundCommandBuffers
++ VkDevice device
++ VkDeviceSize allocationSize
++ map!(u64, VkDeviceSize) boundObjects
++ map!(VkCommandBuffer, VkCommandBuffer) boundCommandBuffers
+ }
+
+ @internal class BufferObject {
+ VkDevice device
+- VkDeviceMemory mem
+- VkDeviceSize memOffset
++ VkDeviceMemory memory
++ VkDeviceSize memoryOffset
+ }
+
+ @internal class BufferViewObject {
+@@ -5036,8 +5035,8 @@ StateObject State
+
+ @internal class ImageObject {
+ VkDevice device
+- VkDeviceMemory mem
+- VkDeviceSize memOffset
++ VkDeviceMemory memory
++ VkDeviceSize memoryOffset
+ }
+
+ @internal class ImageViewObject {
+@@ -5106,7 +5105,7 @@ StateObject State
+ VkDevice device
+ }
+
+-@internal class CmdPoolObject {
++@internal class CommandPoolObject {
+ VkDevice device
+ }
+
+@@ -5138,14 +5137,14 @@ macro ref!QueueObject GetQueue(VkQueue queue) {
+ return State.Queues[queue]
+ }
+
+-macro ref!CmdBufferObject GetCmdBuffer(VkCmdBuffer cmdBuffer) {
+- assert(cmdBuffer in State.CmdBuffers)
+- return State.CmdBuffers[cmdBuffer]
++macro ref!CommandBufferObject GetCommandBuffer(VkCommandBuffer commandBuffer) {
++ assert(commandBuffer in State.CommandBuffers)
++ return State.CommandBuffers[commandBuffer]
+ }
+
+-macro ref!DeviceMemoryObject GetDeviceMemory(VkDeviceMemory mem) {
+- assert(mem in State.DeviceMemories)
+- return State.DeviceMemories[mem]
++macro ref!DeviceMemoryObject GetDeviceMemory(VkDeviceMemory memory) {
++ assert(memory in State.DeviceMemories)
++ return State.DeviceMemories[memory]
+ }
+
+ macro ref!BufferObject GetBuffer(VkBuffer buffer) {
+@@ -5243,9 +5242,9 @@ macro ref!PipelineCacheObject GetPipelineCache(VkPipelineCache pipelineCache) {
+ return State.PipelineCaches[pipelineCache]
+ }
+
+-macro ref!CmdPoolObject GetCmdPool(VkCmdPool cmdPool) {
+- assert(cmdPool in State.CmdPools)
+- return State.CmdPools[cmdPool]
++macro ref!CommandPoolObject GetCommandPool(VkCommandPool commandPool) {
++ assert(commandPool in State.CommandPools)
++ return State.CommandPools[commandPool]
+ }
+
+ macro ref!SurfaceObject GetSurface(VkSurfaceKHR surface) {
+diff --git a/vulkan/include/vulkan/vk_debug_report_lunarg.h b/vulkan/include/vulkan/vk_debug_report_lunarg.h
+index 23bb63c..286c354 100644
+--- a/vulkan/include/vulkan/vk_debug_report_lunarg.h
++++ b/vulkan/include/vulkan/vk_debug_report_lunarg.h
+@@ -83,7 +83,7 @@ typedef enum {
+
+ #define VK_DEBUG_REPORT_EXTENSION_NAME "DEBUG_REPORT"
+
+-VK_DEFINE_NONDISP_HANDLE(VkDbgMsgCallback)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDbgMsgCallback)
+
+ // ------------------------------------------------------------------------------------------------
+ // Enumerations
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index af0ccdf..0130399 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,20 +41,20 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 194, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 196, 0)
+
+
+ #define VK_NULL_HANDLE 0
+
+
+
+-#define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj;
++#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
+
+
+ #if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+- #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T *obj;
++ #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
+ #else
+- #define VK_DEFINE_NONDISP_HANDLE(obj) typedef uint64_t obj;
++ #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
+ #endif
+
+
+@@ -68,28 +68,28 @@ VK_DEFINE_HANDLE(VkInstance)
+ VK_DEFINE_HANDLE(VkPhysicalDevice)
+ VK_DEFINE_HANDLE(VkDevice)
+ VK_DEFINE_HANDLE(VkQueue)
+-VK_DEFINE_NONDISP_HANDLE(VkSemaphore)
+-VK_DEFINE_HANDLE(VkCmdBuffer)
+-VK_DEFINE_NONDISP_HANDLE(VkFence)
+-VK_DEFINE_NONDISP_HANDLE(VkDeviceMemory)
+-VK_DEFINE_NONDISP_HANDLE(VkBuffer)
+-VK_DEFINE_NONDISP_HANDLE(VkImage)
+-VK_DEFINE_NONDISP_HANDLE(VkEvent)
+-VK_DEFINE_NONDISP_HANDLE(VkQueryPool)
+-VK_DEFINE_NONDISP_HANDLE(VkBufferView)
+-VK_DEFINE_NONDISP_HANDLE(VkImageView)
+-VK_DEFINE_NONDISP_HANDLE(VkShaderModule)
+-VK_DEFINE_NONDISP_HANDLE(VkShader)
+-VK_DEFINE_NONDISP_HANDLE(VkPipelineCache)
+-VK_DEFINE_NONDISP_HANDLE(VkPipelineLayout)
+-VK_DEFINE_NONDISP_HANDLE(VkRenderPass)
+-VK_DEFINE_NONDISP_HANDLE(VkPipeline)
+-VK_DEFINE_NONDISP_HANDLE(VkDescriptorSetLayout)
+-VK_DEFINE_NONDISP_HANDLE(VkSampler)
+-VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool)
+-VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet)
+-VK_DEFINE_NONDISP_HANDLE(VkFramebuffer)
+-VK_DEFINE_NONDISP_HANDLE(VkCmdPool)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
++VK_DEFINE_HANDLE(VkCommandBuffer)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShader)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
+
+ #define VK_LOD_CLAMP_NONE 1000.0f
+ #define VK_REMAINING_MIP_LEVELS (~0U)
+@@ -126,7 +126,7 @@ typedef enum {
+ VK_ERROR_INCOMPATIBLE_DRIVER = -9,
+ VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER,
+ VK_RESULT_END_RANGE = VK_INCOMPLETE,
+- VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1),
++ VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1),
+ VK_RESULT_MAX_ENUM = 0x7FFFFFFF
+ } VkResult;
+
+@@ -171,9 +171,9 @@ typedef enum {
+ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 37,
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 38,
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 39,
+- VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 40,
+- VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 41,
+- VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 42,
++ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 40,
++ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 41,
++ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
+@@ -182,29 +182,29 @@ typedef enum {
+ VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 48,
+ VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+ VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO,
+- VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
++ VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+ VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkStructureType;
+
+ typedef enum {
+- VK_SYSTEM_ALLOC_SCOPE_FUNCTION = 0,
+- VK_SYSTEM_ALLOC_SCOPE_OBJECT = 1,
+- VK_SYSTEM_ALLOC_SCOPE_CACHE = 2,
+- VK_SYSTEM_ALLOC_SCOPE_DEVICE = 3,
+- VK_SYSTEM_ALLOC_SCOPE_INSTANCE = 4,
+- VK_SYSTEM_ALLOC_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_SCOPE_FUNCTION,
+- VK_SYSTEM_ALLOC_SCOPE_END_RANGE = VK_SYSTEM_ALLOC_SCOPE_INSTANCE,
+- VK_SYSTEM_ALLOC_SCOPE_NUM = (VK_SYSTEM_ALLOC_SCOPE_INSTANCE - VK_SYSTEM_ALLOC_SCOPE_FUNCTION + 1),
+- VK_SYSTEM_ALLOC_SCOPE_MAX_ENUM = 0x7FFFFFFF
+-} VkSystemAllocScope;
++ VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION = 0,
++ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
++ VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
++ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
++ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
++ VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION,
++ VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
++ VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION + 1),
++ VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
++} VkSystemAllocationScope;
+
+ typedef enum {
+- VK_INTERNAL_ALLOC_TYPE_EXECUTABLE = 0,
+- VK_INTERNAL_ALLOC_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOC_TYPE_EXECUTABLE,
+- VK_INTERNAL_ALLOC_TYPE_END_RANGE = VK_INTERNAL_ALLOC_TYPE_EXECUTABLE,
+- VK_INTERNAL_ALLOC_TYPE_NUM = (VK_INTERNAL_ALLOC_TYPE_EXECUTABLE - VK_INTERNAL_ALLOC_TYPE_EXECUTABLE + 1),
+- VK_INTERNAL_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF
+-} VkInternalAllocType;
++ VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
++ VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
++ VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
++ VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
++ VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
++} VkInternalAllocationType;
+
+ typedef enum {
+ VK_FORMAT_UNDEFINED = 0,
+@@ -383,7 +383,7 @@ typedef enum {
+ VK_FORMAT_B10G10R10A2_SINT = 173,
+ VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
+ VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT,
+- VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1),
++ VK_FORMAT_RANGE_SIZE = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1),
+ VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
+ } VkFormat;
+
+@@ -393,7 +393,7 @@ typedef enum {
+ VK_IMAGE_TYPE_3D = 2,
+ VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
+ VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
+- VK_IMAGE_TYPE_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
++ VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
+ VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkImageType;
+
+@@ -402,7 +402,7 @@ typedef enum {
+ VK_IMAGE_TILING_LINEAR = 1,
+ VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
+ VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
+- VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
++ VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
+ VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
+ } VkImageTiling;
+
+@@ -414,7 +414,7 @@ typedef enum {
+ VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
+ VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
+ VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
+- VK_PHYSICAL_DEVICE_TYPE_NUM = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
++ VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
+ VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkPhysicalDeviceType;
+
+@@ -424,7 +424,7 @@ typedef enum {
+ VK_QUERY_TYPE_TIMESTAMP = 2,
+ VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
+ VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
+- VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
++ VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
+ VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkQueryType;
+
+@@ -433,7 +433,7 @@ typedef enum {
+ VK_SHARING_MODE_CONCURRENT = 1,
+ VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
+ VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
+- VK_SHARING_MODE_NUM = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
++ VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
+ VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkSharingMode;
+
+@@ -444,12 +444,12 @@ typedef enum {
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
+ VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
+ VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
+- VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 6,
+- VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7,
++ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
++ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
+ VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
+ VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
+ VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
+- VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
++ VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
+ VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
+ } VkImageLayout;
+
+@@ -463,7 +463,7 @@ typedef enum {
+ VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
+ VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
+ VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
+- VK_IMAGE_VIEW_TYPE_NUM = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
++ VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
+ VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkImageViewType;
+
+@@ -477,7 +477,7 @@ typedef enum {
+ VK_CHANNEL_SWIZZLE_A = 6,
+ VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_IDENTITY,
+ VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A,
+- VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_IDENTITY + 1),
++ VK_CHANNEL_SWIZZLE_RANGE_SIZE = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_IDENTITY + 1),
+ VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
+ } VkChannelSwizzle;
+
+@@ -486,7 +486,7 @@ typedef enum {
+ VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1,
+ VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX,
+ VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_INSTANCE,
+- VK_VERTEX_INPUT_STEP_RATE_NUM = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1),
++ VK_VERTEX_INPUT_STEP_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1),
+ VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF
+ } VkVertexInputStepRate;
+
+@@ -497,14 +497,14 @@ typedef enum {
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
+- VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 6,
+- VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7,
+- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8,
+- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9,
++ VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
++ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
++ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
++ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
+ VK_PRIMITIVE_TOPOLOGY_PATCH = 10,
+ VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
+ VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH,
+- VK_PRIMITIVE_TOPOLOGY_NUM = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
++ VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
+ VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
+ } VkPrimitiveTopology;
+
+@@ -514,16 +514,16 @@ typedef enum {
+ VK_FILL_MODE_POINTS = 2,
+ VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_SOLID,
+ VK_FILL_MODE_END_RANGE = VK_FILL_MODE_POINTS,
+- VK_FILL_MODE_NUM = (VK_FILL_MODE_POINTS - VK_FILL_MODE_SOLID + 1),
++ VK_FILL_MODE_RANGE_SIZE = (VK_FILL_MODE_POINTS - VK_FILL_MODE_SOLID + 1),
+ VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkFillMode;
+
+ typedef enum {
+- VK_FRONT_FACE_CCW = 0,
+- VK_FRONT_FACE_CW = 1,
+- VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW,
+- VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW,
+- VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1),
++ VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
++ VK_FRONT_FACE_CLOCKWISE = 1,
++ VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
++ VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
++ VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
+ VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
+ } VkFrontFace;
+
+@@ -531,14 +531,14 @@ typedef enum {
+ VK_COMPARE_OP_NEVER = 0,
+ VK_COMPARE_OP_LESS = 1,
+ VK_COMPARE_OP_EQUAL = 2,
+- VK_COMPARE_OP_LESS_EQUAL = 3,
++ VK_COMPARE_OP_LESS_OR_EQUAL = 3,
+ VK_COMPARE_OP_GREATER = 4,
+ VK_COMPARE_OP_NOT_EQUAL = 5,
+- VK_COMPARE_OP_GREATER_EQUAL = 6,
++ VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
+ VK_COMPARE_OP_ALWAYS = 7,
+ VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
+ VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
+- VK_COMPARE_OP_NUM = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
++ VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
+ VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkCompareOp;
+
+@@ -546,14 +546,14 @@ typedef enum {
+ VK_STENCIL_OP_KEEP = 0,
+ VK_STENCIL_OP_ZERO = 1,
+ VK_STENCIL_OP_REPLACE = 2,
+- VK_STENCIL_OP_INC_CLAMP = 3,
+- VK_STENCIL_OP_DEC_CLAMP = 4,
++ VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
++ VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
+ VK_STENCIL_OP_INVERT = 5,
+- VK_STENCIL_OP_INC_WRAP = 6,
+- VK_STENCIL_OP_DEC_WRAP = 7,
++ VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
++ VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
+ VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
+- VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP,
+- VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1),
++ VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
++ VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
+ VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkStencilOp;
+
+@@ -563,11 +563,11 @@ typedef enum {
+ VK_LOGIC_OP_AND_REVERSE = 2,
+ VK_LOGIC_OP_COPY = 3,
+ VK_LOGIC_OP_AND_INVERTED = 4,
+- VK_LOGIC_OP_NOOP = 5,
++ VK_LOGIC_OP_NO_OP = 5,
+ VK_LOGIC_OP_XOR = 6,
+ VK_LOGIC_OP_OR = 7,
+ VK_LOGIC_OP_NOR = 8,
+- VK_LOGIC_OP_EQUIV = 9,
++ VK_LOGIC_OP_EQUIVALENT = 9,
+ VK_LOGIC_OP_INVERT = 10,
+ VK_LOGIC_OP_OR_REVERSE = 11,
+ VK_LOGIC_OP_COPY_INVERTED = 12,
+@@ -576,7 +576,7 @@ typedef enum {
+ VK_LOGIC_OP_SET = 15,
+ VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
+ VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
+- VK_LOGIC_OP_NUM = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
++ VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
+ VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkLogicOp;
+
+@@ -585,12 +585,12 @@ typedef enum {
+ VK_BLEND_ONE = 1,
+ VK_BLEND_SRC_COLOR = 2,
+ VK_BLEND_ONE_MINUS_SRC_COLOR = 3,
+- VK_BLEND_DEST_COLOR = 4,
+- VK_BLEND_ONE_MINUS_DEST_COLOR = 5,
++ VK_BLEND_DST_COLOR = 4,
++ VK_BLEND_ONE_MINUS_DST_COLOR = 5,
+ VK_BLEND_SRC_ALPHA = 6,
+ VK_BLEND_ONE_MINUS_SRC_ALPHA = 7,
+- VK_BLEND_DEST_ALPHA = 8,
+- VK_BLEND_ONE_MINUS_DEST_ALPHA = 9,
++ VK_BLEND_DST_ALPHA = 8,
++ VK_BLEND_ONE_MINUS_DST_ALPHA = 9,
+ VK_BLEND_CONSTANT_COLOR = 10,
+ VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11,
+ VK_BLEND_CONSTANT_ALPHA = 12,
+@@ -602,7 +602,7 @@ typedef enum {
+ VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18,
+ VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO,
+ VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA,
+- VK_BLEND_NUM = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1),
++ VK_BLEND_RANGE_SIZE = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1),
+ VK_BLEND_MAX_ENUM = 0x7FFFFFFF
+ } VkBlend;
+
+@@ -614,7 +614,7 @@ typedef enum {
+ VK_BLEND_OP_MAX = 4,
+ VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
+ VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
+- VK_BLEND_OP_NUM = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
++ VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
+ VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkBlendOp;
+
+@@ -630,7 +630,7 @@ typedef enum {
+ VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
+ VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
+ VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
+- VK_DYNAMIC_STATE_NUM = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
++ VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
+ VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
+ } VkDynamicState;
+
+@@ -639,7 +639,7 @@ typedef enum {
+ VK_FILTER_LINEAR = 1,
+ VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
+ VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
+- VK_FILTER_NUM = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
++ VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
+ VK_FILTER_MAX_ENUM = 0x7FFFFFFF
+ } VkFilter;
+
+@@ -649,7 +649,7 @@ typedef enum {
+ VK_SAMPLER_MIPMAP_MODE_LINEAR = 2,
+ VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_BASE,
+ VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
+- VK_SAMPLER_MIPMAP_MODE_NUM = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_BASE + 1),
++ VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_BASE + 1),
+ VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkSamplerMipmapMode;
+
+@@ -661,7 +661,7 @@ typedef enum {
+ VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
+ VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
+ VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
+- VK_SAMPLER_ADDRESS_MODE_NUM = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
++ VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
+ VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkSamplerAddressMode;
+
+@@ -674,7 +674,7 @@ typedef enum {
+ VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
+ VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
+ VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
+- VK_BORDER_COLOR_NUM = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
++ VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
+ VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
+ } VkBorderColor;
+
+@@ -692,7 +692,7 @@ typedef enum {
+ VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
+ VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
+ VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+- VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
++ VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
+ VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkDescriptorType;
+
+@@ -702,7 +702,7 @@ typedef enum {
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
+ VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
+ VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+- VK_ATTACHMENT_LOAD_OP_NUM = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
++ VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
+ VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkAttachmentLoadOp;
+
+@@ -711,7 +711,7 @@ typedef enum {
+ VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
+ VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
+ VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+- VK_ATTACHMENT_STORE_OP_NUM = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
++ VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
+ VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkAttachmentStoreOp;
+
+@@ -720,34 +720,34 @@ typedef enum {
+ VK_PIPELINE_BIND_POINT_COMPUTE = 1,
+ VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
+ VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
+- VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
++ VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
+ VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
+ } VkPipelineBindPoint;
+
+ typedef enum {
+- VK_CMD_BUFFER_LEVEL_PRIMARY = 0,
+- VK_CMD_BUFFER_LEVEL_SECONDARY = 1,
+- VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY,
+- VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY,
+- VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1),
+- VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
+-} VkCmdBufferLevel;
++ VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
++ VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
++ VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
++ VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
++ VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
++ VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
++} VkCommandBufferLevel;
+
+ typedef enum {
+ VK_INDEX_TYPE_UINT16 = 0,
+ VK_INDEX_TYPE_UINT32 = 1,
+ VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
+ VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
+- VK_INDEX_TYPE_NUM = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
++ VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
+ VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkIndexType;
+
+ typedef enum {
+ VK_RENDER_PASS_CONTENTS_INLINE = 0,
+- VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1,
++ VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
+ VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE,
+- VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS,
+- VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1),
++ VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
++ VK_RENDER_PASS_CONTENTS_RANGE_SIZE = (VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1),
+ VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
+ } VkRenderPassContents;
+
+@@ -764,14 +764,14 @@ typedef enum {
+ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
+ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
+ VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
+- VK_FORMAT_FEATURE_BLIT_SOURCE_BIT = 0x00000400,
+- VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT = 0x00000800,
++ VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
++ VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
+ } VkFormatFeatureFlagBits;
+ typedef VkFlags VkFormatFeatureFlags;
+
+ typedef enum {
+- VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
+- VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
++ VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
++ VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
+ VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
+ VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
+@@ -885,8 +885,8 @@ typedef enum {
+ typedef VkFlags VkBufferCreateFlags;
+
+ typedef enum {
+- VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
+- VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
++ VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
++ VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
+ VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
+ VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
+ VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
+@@ -925,7 +925,7 @@ typedef VkFlags VkPipelineVertexInputStateCreateFlags;
+ typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
+ typedef VkFlags VkPipelineTesselationStateCreateFlags;
+ typedef VkFlags VkPipelineViewportStateCreateFlags;
+-typedef VkFlags VkPipelineRasterStateCreateFlags;
++typedef VkFlags VkPipelineRasterizationStateCreateFlags;
+
+ typedef enum {
+ VK_CULL_MODE_NONE = 0,
+@@ -1014,27 +1014,27 @@ typedef enum {
+ typedef VkFlags VkDependencyFlags;
+
+ typedef enum {
+- VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
+- VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
+-} VkCmdPoolCreateFlagBits;
+-typedef VkFlags VkCmdPoolCreateFlags;
++ VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
++ VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
++} VkCommandPoolCreateFlagBits;
++typedef VkFlags VkCommandPoolCreateFlags;
+
+ typedef enum {
+- VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+-} VkCmdPoolResetFlagBits;
+-typedef VkFlags VkCmdPoolResetFlags;
++ VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
++} VkCommandPoolResetFlagBits;
++typedef VkFlags VkCommandPoolResetFlags;
+
+ typedef enum {
+- VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
+- VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
+- VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
+-} VkCmdBufferUsageFlagBits;
+-typedef VkFlags VkCmdBufferUsageFlags;
++ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
++ VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
++ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
++} VkCommandBufferUsageFlagBits;
++typedef VkFlags VkCommandBufferUsageFlags;
+
+ typedef enum {
+- VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+-} VkCmdBufferResetFlagBits;
+-typedef VkFlags VkCmdBufferResetFlags;
++ VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
++} VkCommandBufferResetFlagBits;
++typedef VkFlags VkCommandBufferResetFlags;
+
+ typedef enum {
+ VK_STENCIL_FACE_NONE = 0,
+@@ -1049,42 +1049,42 @@ typedef enum {
+ } VkQueryControlFlagBits;
+ typedef VkFlags VkQueryControlFlags;
+
+-typedef void* (VKAPI *PFN_vkAllocFunction)(
++typedef void* (VKAPI *PFN_vkAllocationFunction)(
+ void* pUserData,
+ size_t size,
+ size_t alignment,
+- VkSystemAllocScope allocScope);
++ VkSystemAllocationScope allocationScope);
+
+-typedef void* (VKAPI *PFN_vkReallocFunction)(
++typedef void* (VKAPI *PFN_vkReallocationFunction)(
+ void* pUserData,
+ void* pOriginal,
+ size_t size,
+ size_t alignment,
+- VkSystemAllocScope allocScope);
++ VkSystemAllocationScope allocationScope);
+
+ typedef void (VKAPI *PFN_vkFreeFunction)(
+ void* pUserData,
+- void* pMem);
++ void* pMemory);
+
+-typedef void (VKAPI *PFN_vkInternalAllocNotification)(
++typedef void (VKAPI *PFN_vkInternalAllocationNotification)(
+ void* pUserData,
+ size_t size,
+- VkInternalAllocType allocType,
+- VkSystemAllocScope allocScope);
++ VkInternalAllocationType allocationType,
++ VkSystemAllocationScope allocationScope);
+
+ typedef void (VKAPI *PFN_vkInternalFreeNotification)(
+ void* pUserData,
+ size_t size,
+- VkInternalAllocType allocType,
+- VkSystemAllocScope allocScope);
++ VkInternalAllocationType allocationType,
++ VkSystemAllocationScope allocationScope);
+
+ typedef void (VKAPI *PFN_vkVoidFunction)(void);
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- const char* pAppName;
+- uint32_t appVersion;
++ const char* pApplicationName;
++ uint32_t applicationVersion;
+ const char* pEngineName;
+ uint32_t engineVersion;
+ uint32_t apiVersion;
+@@ -1094,7 +1094,7 @@ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ VkInstanceCreateFlags flags;
+- const VkApplicationInfo* pAppInfo;
++ const VkApplicationInfo* pApplicationInfo;
+ uint32_t enabledLayerNameCount;
+ const char*const* ppEnabledLayerNames;
+ uint32_t enabledExtensionNameCount;
+@@ -1103,12 +1103,12 @@ typedef struct {
+
+ typedef struct {
+ void* pUserData;
+- PFN_vkAllocFunction pfnAlloc;
+- PFN_vkReallocFunction pfnRealloc;
++ PFN_vkAllocationFunction pfnAllocation;
++ PFN_vkReallocationFunction pfnReallocation;
+ PFN_vkFreeFunction pfnFree;
+- PFN_vkInternalAllocNotification pfnInternalAlloc;
++ PFN_vkInternalAllocationNotification pfnInternalAllocation;
+ PFN_vkInternalFreeNotification pfnInternalFree;
+-} VkAllocCallbacks;
++} VkAllocationCallbacks;
+
+ typedef struct {
+ VkBool32 robustBufferAccess;
+@@ -1118,7 +1118,7 @@ typedef struct {
+ VkBool32 geometryShader;
+ VkBool32 tessellationShader;
+ VkBool32 sampleRateShading;
+- VkBool32 dualSourceBlend;
++ VkBool32 dualSrcBlend;
+ VkBool32 logicOp;
+ VkBool32 multiDrawIndirect;
+ VkBool32 depthClamp;
+@@ -1215,7 +1215,7 @@ typedef struct {
+ uint32_t maxVertexInputAttributeOffset;
+ uint32_t maxVertexInputBindingStride;
+ uint32_t maxVertexOutputComponents;
+- uint32_t maxTessellationGenLevel;
++ uint32_t maxTessellationGenerationLevel;
+ uint32_t maxTessellationPatchSize;
+ uint32_t maxTessellationControlPerVertexInputComponents;
+ uint32_t maxTessellationControlPerVertexOutputComponents;
+@@ -1230,7 +1230,7 @@ typedef struct {
+ uint32_t maxGeometryTotalOutputComponents;
+ uint32_t maxFragmentInputComponents;
+ uint32_t maxFragmentOutputAttachments;
+- uint32_t maxFragmentDualSourceAttachments;
++ uint32_t maxFragmentDualSrcAttachments;
+ uint32_t maxFragmentCombinedOutputResources;
+ uint32_t maxComputeSharedMemorySize;
+ uint32_t maxComputeWorkGroupCount[3];
+@@ -1352,14 +1352,14 @@ typedef struct {
+ } VkDeviceCreateInfo;
+
+ typedef struct {
+- char extName[VK_MAX_EXTENSION_NAME];
++ char extensionName[VK_MAX_EXTENSION_NAME];
+ uint32_t specVersion;
+ } VkExtensionProperties;
+
+ typedef struct {
+ char layerName[VK_MAX_EXTENSION_NAME];
+ uint32_t specVersion;
+- uint32_t implVersion;
++ uint32_t implementationVersion;
+ char description[VK_MAX_DESCRIPTION];
+ } VkLayerProperties;
+
+@@ -1369,7 +1369,7 @@ typedef struct {
+ uint32_t waitSemaphoreCount;
+ const VkSemaphore* pWaitSemaphores;
+ uint32_t commandBufferCount;
+- const VkCmdBuffer* pCommandBuffers;
++ const VkCommandBuffer* pCommandBuffers;
+ uint32_t signalSemaphoreCount;
+ const VkSemaphore* pSignalSemaphores;
+ } VkSubmitInfo;
+@@ -1379,12 +1379,12 @@ typedef struct {
+ const void* pNext;
+ VkDeviceSize allocationSize;
+ uint32_t memoryTypeIndex;
+-} VkMemoryAllocInfo;
++} VkMemoryAllocateInfo;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkDeviceMemory mem;
++ VkDeviceMemory memory;
+ VkDeviceSize offset;
+ VkDeviceSize size;
+ } VkMappedMemoryRange;
+@@ -1412,8 +1412,8 @@ typedef struct {
+ typedef struct {
+ VkDeviceSize resourceOffset;
+ VkDeviceSize size;
+- VkDeviceMemory mem;
+- VkDeviceSize memOffset;
++ VkDeviceMemory memory;
++ VkDeviceSize memoryOffset;
+ VkSparseMemoryBindFlags flags;
+ } VkSparseMemoryBind;
+
+@@ -1445,8 +1445,8 @@ typedef struct {
+ VkImageSubresource subresource;
+ VkOffset3D offset;
+ VkExtent3D extent;
+- VkDeviceMemory mem;
+- VkDeviceSize memOffset;
++ VkDeviceMemory memory;
++ VkDeviceSize memoryOffset;
+ VkSparseMemoryBindFlags flags;
+ } VkSparseImageMemoryBind;
+
+@@ -1554,9 +1554,9 @@ typedef struct {
+ typedef struct {
+ VkImageAspectFlags aspectMask;
+ uint32_t baseMipLevel;
+- uint32_t numLevels;
++ uint32_t levelCount;
+ uint32_t baseArrayLayer;
+- uint32_t numLayers;
++ uint32_t layerCount;
+ } VkImageSubresourceRange;
+
+ typedef struct {
+@@ -1593,7 +1593,6 @@ typedef struct {
+ VkPipelineCacheCreateFlags flags;
+ size_t initialDataSize;
+ const void* pInitialData;
+- size_t maxSize;
+ } VkPipelineCacheCreateInfo;
+
+ typedef struct {
+@@ -1692,7 +1691,7 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkPipelineRasterStateCreateFlags flags;
++ VkPipelineRasterizationStateCreateFlags flags;
+ VkBool32 depthClampEnable;
+ VkBool32 rasterizerDiscardEnable;
+ VkFillMode fillMode;
+@@ -1703,13 +1702,13 @@ typedef struct {
+ float depthBiasClamp;
+ float depthBiasSlopeFactor;
+ float lineWidth;
+-} VkPipelineRasterStateCreateInfo;
++} VkPipelineRasterizationStateCreateInfo;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineMultisampleStateCreateFlags flags;
+- uint32_t rasterSamples;
++ uint32_t rasterizationSamples;
+ VkBool32 sampleShadingEnable;
+ float minSampleShading;
+ const VkSampleMask* pSampleMask;
+@@ -1745,10 +1744,10 @@ typedef struct {
+ typedef struct {
+ VkBool32 blendEnable;
+ VkBlend srcBlendColor;
+- VkBlend destBlendColor;
++ VkBlend dstBlendColor;
+ VkBlendOp blendOpColor;
+ VkBlend srcBlendAlpha;
+- VkBlend destBlendAlpha;
++ VkBlend dstBlendAlpha;
+ VkBlendOp blendOpAlpha;
+ VkChannelFlags channelWriteMask;
+ } VkPipelineColorBlendAttachmentState;
+@@ -1782,7 +1781,7 @@ typedef struct {
+ const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
+ const VkPipelineTessellationStateCreateInfo* pTessellationState;
+ const VkPipelineViewportStateCreateInfo* pViewportState;
+- const VkPipelineRasterStateCreateInfo* pRasterState;
++ const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
+ const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
+ const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
+ const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
+@@ -1875,7 +1874,7 @@ typedef struct {
+ VkDescriptorPool descriptorPool;
+ uint32_t setLayoutCount;
+ const VkDescriptorSetLayout* pSetLayouts;
+-} VkDescriptorSetAllocInfo;
++} VkDescriptorSetAllocateInfo;
+
+ typedef struct {
+ VkSampler sampler;
+@@ -1892,9 +1891,9 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkDescriptorSet destSet;
+- uint32_t destBinding;
+- uint32_t destArrayElement;
++ VkDescriptorSet dstSet;
++ uint32_t dstBinding;
++ uint32_t dstArrayElement;
+ uint32_t descriptorCount;
+ VkDescriptorType descriptorType;
+ const VkDescriptorImageInfo* pImageInfo;
+@@ -1908,9 +1907,9 @@ typedef struct {
+ VkDescriptorSet srcSet;
+ uint32_t srcBinding;
+ uint32_t srcArrayElement;
+- VkDescriptorSet destSet;
+- uint32_t destBinding;
+- uint32_t destArrayElement;
++ VkDescriptorSet dstSet;
++ uint32_t dstBinding;
++ uint32_t dstArrayElement;
+ uint32_t descriptorCount;
+ } VkCopyDescriptorSet;
+
+@@ -1958,9 +1957,9 @@ typedef struct {
+
+ typedef struct {
+ uint32_t srcSubpass;
+- uint32_t destSubpass;
++ uint32_t dstSubpass;
+ VkPipelineStageFlags srcStageMask;
+- VkPipelineStageFlags destStageMask;
++ VkPipelineStageFlags dstStageMask;
+ VkMemoryOutputFlags outputMask;
+ VkMemoryInputFlags inputMask;
+ VkDependencyFlags dependencyFlags;
+@@ -1981,30 +1980,30 @@ typedef struct {
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkCmdPoolCreateFlags flags;
++ VkCommandPoolCreateFlags flags;
+ uint32_t queueFamilyIndex;
+-} VkCmdPoolCreateInfo;
++} VkCommandPoolCreateInfo;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkCmdPool cmdPool;
+- VkCmdBufferLevel level;
++ VkCommandPool commandPool;
++ VkCommandBufferLevel level;
+ uint32_t bufferCount;
+-} VkCmdBufferAllocInfo;
++} VkCommandBufferAllocateInfo;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+- VkCmdBufferUsageFlags flags;
++ VkCommandBufferUsageFlags flags;
+ VkRenderPass renderPass;
+ uint32_t subpass;
+ VkFramebuffer framebuffer;
+-} VkCmdBufferBeginInfo;
++} VkCommandBufferBeginInfo;
+
+ typedef struct {
+ VkDeviceSize srcOffset;
+- VkDeviceSize destOffset;
++ VkDeviceSize dstOffset;
+ VkDeviceSize size;
+ } VkBufferCopy;
+
+@@ -2012,14 +2011,14 @@ typedef struct {
+ VkImageAspectFlags aspect;
+ uint32_t mipLevel;
+ uint32_t baseArrayLayer;
+- uint32_t numLayers;
++ uint32_t layerCount;
+ } VkImageSubresourceCopy;
+
+ typedef struct {
+ VkImageSubresourceCopy srcSubresource;
+ VkOffset3D srcOffset;
+- VkImageSubresourceCopy destSubresource;
+- VkOffset3D destOffset;
++ VkImageSubresourceCopy dstSubresource;
++ VkOffset3D dstOffset;
+ VkExtent3D extent;
+ } VkImageCopy;
+
+@@ -2027,9 +2026,9 @@ typedef struct {
+ VkImageSubresourceCopy srcSubresource;
+ VkOffset3D srcOffset;
+ VkExtent3D srcExtent;
+- VkImageSubresourceCopy destSubresource;
+- VkOffset3D destOffset;
+- VkExtent3D destExtent;
++ VkImageSubresourceCopy dstSubresource;
++ VkOffset3D dstOffset;
++ VkExtent3D dstExtent;
+ } VkImageBlit;
+
+ typedef struct {
+@@ -2066,14 +2065,14 @@ typedef struct {
+ typedef struct {
+ VkRect2D rect;
+ uint32_t baseArrayLayer;
+- uint32_t numLayers;
++ uint32_t layerCount;
+ } VkClearRect;
+
+ typedef struct {
+ VkImageSubresourceCopy srcSubresource;
+ VkOffset3D srcOffset;
+- VkImageSubresourceCopy destSubresource;
+- VkOffset3D destOffset;
++ VkImageSubresourceCopy dstSubresource;
++ VkOffset3D dstOffset;
+ VkExtent3D extent;
+ } VkImageResolve;
+
+@@ -2093,7 +2092,7 @@ typedef struct {
+ VkMemoryOutputFlags outputMask;
+ VkMemoryInputFlags inputMask;
+ uint32_t srcQueueFamilyIndex;
+- uint32_t destQueueFamilyIndex;
++ uint32_t dstQueueFamilyIndex;
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ VkDeviceSize size;
+@@ -2103,7 +2102,7 @@ typedef struct {
+ uint32_t x;
+ uint32_t y;
+ uint32_t z;
+-} VkDispatchIndirectCmd;
++} VkDispatchIndirectCommand;
+
+ typedef struct {
+ uint32_t indexCount;
+@@ -2111,14 +2110,14 @@ typedef struct {
+ uint32_t firstIndex;
+ int32_t vertexOffset;
+ uint32_t firstInstance;
+-} VkDrawIndexedIndirectCmd;
++} VkDrawIndexedIndirectCommand;
+
+ typedef struct {
+ uint32_t vertexCount;
+ uint32_t instanceCount;
+ uint32_t firstVertex;
+ uint32_t firstInstance;
+-} VkDrawIndirectCmd;
++} VkDrawIndirectCommand;
+
+ typedef struct {
+ VkStructureType sType;
+@@ -2128,7 +2127,7 @@ typedef struct {
+ VkImageLayout oldLayout;
+ VkImageLayout newLayout;
+ uint32_t srcQueueFamilyIndex;
+- uint32_t destQueueFamilyIndex;
++ uint32_t dstQueueFamilyIndex;
+ VkImage image;
+ VkImageSubresourceRange subresourceRange;
+ } VkImageMemoryBarrier;
+@@ -2141,8 +2140,8 @@ typedef struct {
+ } VkMemoryBarrier;
+
+
+-typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance);
+-typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
++typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+@@ -2152,8 +2151,8 @@ typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDev
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+ typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
+ typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
+-typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice);
+-typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
++typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+ typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+ typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+@@ -2162,134 +2161,134 @@ typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamily
+ typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
+ typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
+ typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
+-typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem);
+-typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
+-typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
+-typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+-typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
++typedef VkResult (VKAPI *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
++typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
++typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
++typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
++typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
+ typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+-typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
+-typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
++typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
++typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+ typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+ typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+ typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
+ typedef VkResult (VKAPI *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
+-typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence);
+-typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
++typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
+ typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
+ typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
+-typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore);
+-typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent);
+-typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
++typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
++typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
+ typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
+ typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
+-typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool);
+-typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
++typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+-typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer);
+-typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView);
+-typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage);
+-typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
++typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
++typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
++typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
+ typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+-typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView);
+-typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShaderModule);
+-typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader);
+-typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
+-typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
++typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
++typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader);
++typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
++typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+-typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+-typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
+-typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
+-typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
+-typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler);
+-typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
+-typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
+-typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
++typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
++typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
++typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
++typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
++typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
++typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
++typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+-typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
++typedef VkResult (VKAPI *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
+ typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
+ typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+-typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
+-typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass);
+-typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
++typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
++typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
+ typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+-typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool);
+-typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
+-typedef VkResult (VKAPI *PFN_vkAllocCommandBuffers)(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
+-typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers);
+-typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
+-typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
+-typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
+-typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+-typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
+-typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
+-typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth);
+-typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
+-typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConstants[4]);
+-typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
+-typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
+-typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
+-typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
+-typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+-typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+-typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+-typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+-typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+-typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+-typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+-typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
+-typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
+-typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+-typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+-typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+-typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+-typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+-typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
+-typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data);
+-typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+-typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+-typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+-typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+-typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+-typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+-typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+-typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+-typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+-typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
+-typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+-typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values);
+-typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+-typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents);
+-typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer);
+-typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers);
++typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
++typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool CommandPool, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool CommandPool, VkCommandPoolResetFlags flags);
++typedef VkResult (VKAPI *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
++typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool CommandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
++typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
++typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
++typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
++typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
++typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);
++typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
++typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
++typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
++typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
++typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
++typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
++typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
++typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
++typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
++typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
++typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
++typedef void (VKAPI *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
++typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
++typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
++typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
++typedef void (VKAPI *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
++typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
++typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
++typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
++typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
++typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
++typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
++typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData);
++typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
++typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
++typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
++typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
++typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
++typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
++typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
++typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
++typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
++typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
++typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot);
++typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
++typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
++typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
++typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values);
++typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
++typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkRenderPassContents contents);
++typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
++typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers);
+
+ #ifdef VK_PROTOTYPES
+ VkResult VKAPI vkCreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance);
+
+ void VKAPI vkDestroyInstance(
+ VkInstance instance,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkEnumeratePhysicalDevices(
+ VkInstance instance,
+@@ -2338,12 +2337,12 @@ PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
+ VkResult VKAPI vkCreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice);
+
+ void VKAPI vkDestroyDevice(
+ VkDevice device,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkEnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+@@ -2383,20 +2382,20 @@ VkResult VKAPI vkQueueWaitIdle(
+ VkResult VKAPI vkDeviceWaitIdle(
+ VkDevice device);
+
+-VkResult VKAPI vkAllocMemory(
++VkResult VKAPI vkAllocateMemory(
+ VkDevice device,
+- const VkMemoryAllocInfo* pAllocInfo,
+- const VkAllocCallbacks* pAllocator,
+- VkDeviceMemory* pMem);
++ const VkMemoryAllocateInfo* pAllocateInfo,
++ const VkAllocationCallbacks* pAllocator,
++ VkDeviceMemory* pMemory);
+
+ void VKAPI vkFreeMemory(
+ VkDevice device,
+- VkDeviceMemory mem,
+- const VkAllocCallbacks* pAllocator);
++ VkDeviceMemory memory,
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkMapMemory(
+ VkDevice device,
+- VkDeviceMemory mem,
++ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+@@ -2404,17 +2403,17 @@ VkResult VKAPI vkMapMemory(
+
+ void VKAPI vkUnmapMemory(
+ VkDevice device,
+- VkDeviceMemory mem);
++ VkDeviceMemory memory);
+
+ VkResult VKAPI vkFlushMappedMemoryRanges(
+ VkDevice device,
+- uint32_t memRangeCount,
+- const VkMappedMemoryRange* pMemRanges);
++ uint32_t memoryRangeCount,
++ const VkMappedMemoryRange* pMemoryRanges);
+
+ VkResult VKAPI vkInvalidateMappedMemoryRanges(
+ VkDevice device,
+- uint32_t memRangeCount,
+- const VkMappedMemoryRange* pMemRanges);
++ uint32_t memoryRangeCount,
++ const VkMappedMemoryRange* pMemoryRanges);
+
+ void VKAPI vkGetDeviceMemoryCommitment(
+ VkDevice device,
+@@ -2424,14 +2423,14 @@ void VKAPI vkGetDeviceMemoryCommitment(
+ VkResult VKAPI vkBindBufferMemory(
+ VkDevice device,
+ VkBuffer buffer,
+- VkDeviceMemory mem,
+- VkDeviceSize memOffset);
++ VkDeviceMemory memory,
++ VkDeviceSize memoryOffset);
+
+ VkResult VKAPI vkBindImageMemory(
+ VkDevice device,
+ VkImage image,
+- VkDeviceMemory mem,
+- VkDeviceSize memOffset);
++ VkDeviceMemory memory,
++ VkDeviceSize memoryOffset);
+
+ void VKAPI vkGetBufferMemoryRequirements(
+ VkDevice device,
+@@ -2468,13 +2467,13 @@ VkResult VKAPI vkQueueBindSparse(
+ VkResult VKAPI vkCreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+
+ void VKAPI vkDestroyFence(
+ VkDevice device,
+ VkFence fence,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkResetFences(
+ VkDevice device,
+@@ -2495,24 +2494,24 @@ VkResult VKAPI vkWaitForFences(
+ VkResult VKAPI vkCreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore);
+
+ void VKAPI vkDestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent);
+
+ void VKAPI vkDestroyEvent(
+ VkDevice device,
+ VkEvent event,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkGetEventStatus(
+ VkDevice device,
+@@ -2529,13 +2528,13 @@ VkResult VKAPI vkResetEvent(
+ VkResult VKAPI vkCreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool);
+
+ void VKAPI vkDestroyQueryPool(
+ VkDevice device,
+ VkQueryPool queryPool,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkGetQueryPoolResults(
+ VkDevice device,
+@@ -2550,35 +2549,35 @@ VkResult VKAPI vkGetQueryPoolResults(
+ VkResult VKAPI vkCreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer);
+
+ void VKAPI vkDestroyBuffer(
+ VkDevice device,
+ VkBuffer buffer,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView);
+
+ void VKAPI vkDestroyBufferView(
+ VkDevice device,
+ VkBufferView bufferView,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage);
+
+ void VKAPI vkDestroyImage(
+ VkDevice device,
+ VkImage image,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ void VKAPI vkGetImageSubresourceLayout(
+ VkDevice device,
+@@ -2589,46 +2588,46 @@ void VKAPI vkGetImageSubresourceLayout(
+ VkResult VKAPI vkCreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView);
+
+ void VKAPI vkDestroyImageView(
+ VkDevice device,
+ VkImageView imageView,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule);
+
+ void VKAPI vkDestroyShaderModule(
+ VkDevice device,
+ VkShaderModule shaderModule,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateShader(
+ VkDevice device,
+ const VkShaderCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkShader* pShader);
+
+ void VKAPI vkDestroyShader(
+ VkDevice device,
+ VkShader shader,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache);
+
+ void VKAPI vkDestroyPipelineCache(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkGetPipelineCacheData(
+ VkDevice device,
+@@ -2638,7 +2637,7 @@ VkResult VKAPI vkGetPipelineCacheData(
+
+ VkResult VKAPI vkMergePipelineCaches(
+ VkDevice device,
+- VkPipelineCache destCache,
++ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches);
+
+@@ -2647,7 +2646,7 @@ VkResult VKAPI vkCreateGraphicsPipelines(
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+
+ VkResult VKAPI vkCreateComputePipelines(
+@@ -2655,66 +2654,66 @@ VkResult VKAPI vkCreateComputePipelines(
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+
+ void VKAPI vkDestroyPipeline(
+ VkDevice device,
+ VkPipeline pipeline,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout);
+
+ void VKAPI vkDestroyPipelineLayout(
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler);
+
+ void VKAPI vkDestroySampler(
+ VkDevice device,
+ VkSampler sampler,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout);
+
+ void VKAPI vkDestroyDescriptorSetLayout(
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateDescriptorPool(
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool);
+
+ void VKAPI vkDestroyDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkResetDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags);
+
+-VkResult VKAPI vkAllocDescriptorSets(
++VkResult VKAPI vkAllocateDescriptorSets(
+ VkDevice device,
+- const VkDescriptorSetAllocInfo* pAllocInfo,
++ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets);
+
+ VkResult VKAPI vkFreeDescriptorSets(
+@@ -2733,24 +2732,24 @@ void VKAPI vkUpdateDescriptorSets(
+ VkResult VKAPI vkCreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer);
+
+ void VKAPI vkDestroyFramebuffer(
+ VkDevice device,
+ VkFramebuffer framebuffer,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkCreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass);
+
+ void VKAPI vkDestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass,
+- const VkAllocCallbacks* pAllocator);
++ const VkAllocationCallbacks* pAllocator);
+
+ void VKAPI vkGetRenderAreaGranularity(
+ VkDevice device,
+@@ -2759,93 +2758,93 @@ void VKAPI vkGetRenderAreaGranularity(
+
+ VkResult VKAPI vkCreateCommandPool(
+ VkDevice device,
+- const VkCmdPoolCreateInfo* pCreateInfo,
+- const VkAllocCallbacks* pAllocator,
+- VkCmdPool* pCmdPool);
++ const VkCommandPoolCreateInfo* pCreateInfo,
++ const VkAllocationCallbacks* pAllocator,
++ VkCommandPool* pCommandPool);
+
+ void VKAPI vkDestroyCommandPool(
+ VkDevice device,
+- VkCmdPool cmdPool,
+- const VkAllocCallbacks* pAllocator);
++ VkCommandPool CommandPool,
++ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkResetCommandPool(
+ VkDevice device,
+- VkCmdPool cmdPool,
+- VkCmdPoolResetFlags flags);
++ VkCommandPool CommandPool,
++ VkCommandPoolResetFlags flags);
+
+-VkResult VKAPI vkAllocCommandBuffers(
++VkResult VKAPI vkAllocateCommandBuffers(
+ VkDevice device,
+- const VkCmdBufferAllocInfo* pAllocInfo,
+- VkCmdBuffer* pCmdBuffers);
++ const VkCommandBufferAllocateInfo* pAllocateInfo,
++ VkCommandBuffer* pCommandBuffers);
+
+ void VKAPI vkFreeCommandBuffers(
+ VkDevice device,
+- VkCmdPool cmdPool,
++ VkCommandPool CommandPool,
+ uint32_t commandBufferCount,
+- const VkCmdBuffer* pCommandBuffers);
++ const VkCommandBuffer* pCommandBuffers);
+
+ VkResult VKAPI vkBeginCommandBuffer(
+- VkCmdBuffer cmdBuffer,
+- const VkCmdBufferBeginInfo* pBeginInfo);
++ VkCommandBuffer commandBuffer,
++ const VkCommandBufferBeginInfo* pBeginInfo);
+
+ VkResult VKAPI vkEndCommandBuffer(
+- VkCmdBuffer cmdBuffer);
++ VkCommandBuffer commandBuffer);
+
+ VkResult VKAPI vkResetCommandBuffer(
+- VkCmdBuffer cmdBuffer,
+- VkCmdBufferResetFlags flags);
++ VkCommandBuffer commandBuffer,
++ VkCommandBufferResetFlags flags);
+
+ void VKAPI vkCmdBindPipeline(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline);
+
+ void VKAPI vkCmdSetViewport(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ uint32_t viewportCount,
+ const VkViewport* pViewports);
+
+ void VKAPI vkCmdSetScissor(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors);
+
+ void VKAPI vkCmdSetLineWidth(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ float lineWidth);
+
+ void VKAPI vkCmdSetDepthBias(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor);
+
+ void VKAPI vkCmdSetBlendConstants(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ const float blendConstants[4]);
+
+ void VKAPI vkCmdSetDepthBounds(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ float minDepthBounds,
+ float maxDepthBounds);
+
+ void VKAPI vkCmdSetStencilCompareMask(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t stencilCompareMask);
+
+ void VKAPI vkCmdSetStencilWriteMask(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t stencilWriteMask);
+
+ void VKAPI vkCmdSetStencilReference(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t stencilReference);
+
+ void VKAPI vkCmdBindDescriptorSets(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+@@ -2855,27 +2854,27 @@ void VKAPI vkCmdBindDescriptorSets(
+ const uint32_t* pDynamicOffsets);
+
+ void VKAPI vkCmdBindIndexBuffer(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType);
+
+ void VKAPI vkCmdBindVertexBuffers(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ uint32_t startBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets);
+
+ void VKAPI vkCmdDraw(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ uint32_t vertexCount,
+ uint32_t instanceCount,
+ uint32_t firstVertex,
+ uint32_t firstInstance);
+
+ void VKAPI vkCmdDrawIndexed(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ uint32_t indexCount,
+ uint32_t instanceCount,
+ uint32_t firstIndex,
+@@ -2883,88 +2882,88 @@ void VKAPI vkCmdDrawIndexed(
+ uint32_t firstInstance);
+
+ void VKAPI vkCmdDrawIndirect(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+
+ void VKAPI vkCmdDrawIndexedIndirect(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+
+ void VKAPI vkCmdDispatch(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ uint32_t x,
+ uint32_t y,
+ uint32_t z);
+
+ void VKAPI vkCmdDispatchIndirect(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset);
+
+ void VKAPI vkCmdCopyBuffer(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+- VkBuffer destBuffer,
++ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions);
+
+ void VKAPI vkCmdCopyImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+- VkImage destImage,
+- VkImageLayout destImageLayout,
++ VkImage dstImage,
++ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy* pRegions);
+
+ void VKAPI vkCmdBlitImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+- VkImage destImage,
+- VkImageLayout destImageLayout,
++ VkImage dstImage,
++ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter);
+
+ void VKAPI vkCmdCopyBufferToImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+- VkImage destImage,
+- VkImageLayout destImageLayout,
++ VkImage dstImage,
++ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+
+ void VKAPI vkCmdCopyImageToBuffer(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+- VkBuffer destBuffer,
++ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+
+ void VKAPI vkCmdUpdateBuffer(
+- VkCmdBuffer cmdBuffer,
+- VkBuffer destBuffer,
+- VkDeviceSize destOffset,
++ VkCommandBuffer commandBuffer,
++ VkBuffer dstBuffer,
++ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const uint32_t* pData);
+
+ void VKAPI vkCmdFillBuffer(
+- VkCmdBuffer cmdBuffer,
+- VkBuffer destBuffer,
+- VkDeviceSize destOffset,
++ VkCommandBuffer commandBuffer,
++ VkBuffer dstBuffer,
++ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data);
+
+ void VKAPI vkCmdClearColorImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+@@ -2972,7 +2971,7 @@ void VKAPI vkCmdClearColorImage(
+ const VkImageSubresourceRange* pRanges);
+
+ void VKAPI vkCmdClearDepthStencilImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+@@ -2980,83 +2979,83 @@ void VKAPI vkCmdClearDepthStencilImage(
+ const VkImageSubresourceRange* pRanges);
+
+ void VKAPI vkCmdClearAttachments(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkClearRect* pRects);
+
+ void VKAPI vkCmdResolveImage(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+- VkImage destImage,
+- VkImageLayout destImageLayout,
++ VkImage dstImage,
++ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve* pRegions);
+
+ void VKAPI vkCmdSetEvent(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+
+ void VKAPI vkCmdResetEvent(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+
+ void VKAPI vkCmdWaitEvents(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent* pEvents,
+ VkPipelineStageFlags srcStageMask,
+- VkPipelineStageFlags destStageMask,
+- uint32_t memBarrierCount,
+- const void* const* ppMemBarriers);
++ VkPipelineStageFlags dstStageMask,
++ uint32_t memoryBarrierCount,
++ const void* const* ppMemoryBarriers);
+
+ void VKAPI vkCmdPipelineBarrier(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+- VkPipelineStageFlags destStageMask,
++ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+- uint32_t memBarrierCount,
+- const void* const* ppMemBarriers);
++ uint32_t memoryBarrierCount,
++ const void* const* ppMemoryBarriers);
+
+ void VKAPI vkCmdBeginQuery(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t slot,
+ VkQueryControlFlags flags);
+
+ void VKAPI vkCmdEndQuery(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t slot);
+
+ void VKAPI vkCmdResetQueryPool(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t startQuery,
+ uint32_t queryCount);
+
+ void VKAPI vkCmdWriteTimestamp(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t slot);
+
+ void VKAPI vkCmdCopyQueryPoolResults(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t startQuery,
+ uint32_t queryCount,
+- VkBuffer destBuffer,
+- VkDeviceSize destOffset,
++ VkBuffer dstBuffer,
++ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+
+ void VKAPI vkCmdPushConstants(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+@@ -3064,25 +3063,25 @@ void VKAPI vkCmdPushConstants(
+ const void* values);
+
+ void VKAPI vkCmdBeginRenderPass(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkRenderPassContents contents);
+
+ void VKAPI vkCmdNextSubpass(
+- VkCmdBuffer cmdBuffer,
++ VkCommandBuffer commandBuffer,
+ VkRenderPassContents contents);
+
+ void VKAPI vkCmdEndRenderPass(
+- VkCmdBuffer cmdBuffer);
++ VkCommandBuffer commandBuffer);
+
+ void VKAPI vkCmdExecuteCommands(
+- VkCmdBuffer cmdBuffer,
+- uint32_t cmdBuffersCount,
+- const VkCmdBuffer* pCmdBuffers);
++ VkCommandBuffer commandBuffer,
++ uint32_t commandBuffersCount,
++ const VkCommandBuffer* pCommandBuffers);
+ #endif
+
+ #define vk_ext_khr_surface 1
+-VK_DEFINE_NONDISP_HANDLE(VkSurfaceKHR)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
+
+ #define VK_EXT_KHR_SURFACE_REVISION 20
+ #define VK_EXT_KHR_SURFACE_EXTENSION_NUMBER 1
+@@ -3102,7 +3101,7 @@ typedef enum {
+ VK_SURFACE_TRANSFORM_INHERIT_KHR = 8,
+ VK_SURFACE_TRANSFORM_BEGIN_RANGE = VK_SURFACE_TRANSFORM_NONE_KHR,
+ VK_SURFACE_TRANSFORM_END_RANGE = VK_SURFACE_TRANSFORM_INHERIT_KHR,
+- VK_SURFACE_TRANSFORM_NUM = (VK_SURFACE_TRANSFORM_INHERIT_KHR - VK_SURFACE_TRANSFORM_NONE_KHR + 1),
++ VK_SURFACE_TRANSFORM_RANGE_SIZE = (VK_SURFACE_TRANSFORM_INHERIT_KHR - VK_SURFACE_TRANSFORM_NONE_KHR + 1),
+ VK_SURFACE_TRANSFORM_MAX_ENUM = 0x7FFFFFFF
+ } VkSurfaceTransformKHR;
+
+@@ -3110,7 +3109,7 @@ typedef enum {
+ VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0,
+ VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
+ VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
+- VK_COLORSPACE_NUM = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1),
++ VK_COLORSPACE_RANGE_SIZE = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1),
+ VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF
+ } VkColorSpaceKHR;
+
+@@ -3121,7 +3120,7 @@ typedef enum {
+ VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
+ VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR,
+ VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+- VK_PRESENT_MODE_NUM = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
++ VK_PRESENT_MODE_RANGE_SIZE = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
+ VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkPresentModeKHR;
+
+@@ -3202,14 +3201,14 @@ VkResult VKAPI vkGetPhysicalDeviceSurfacePresentModesKHR(
+ #endif
+
+ #define vk_ext_khr_swapchain 1
+-VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
+
+ #define VK_EXT_KHR_SWAPCHAIN_REVISION 62
+ #define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+ #define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
+ #define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
+ #define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801)
+-#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR ((VkImageLayout)(int)0xc0000802)
++#define VK_IMAGE_LAYOUT_PRESENT_SRC_KHR ((VkImageLayout)(int)0xc0000802)
+ #define VK_SUBOPTIMAL_KHR ((VkResult)(int)0x40000403)
+ #define VK_ERROR_OUT_OF_DATE_KHR ((VkResult)(int)0xc0000804)
+
+@@ -3280,8 +3279,8 @@ VkResult VKAPI vkQueuePresentKHR(
+ #endif
+
+ #define vk_ext_khr_display 1
+-VK_DEFINE_NONDISP_HANDLE(VkDisplayKHR)
+-VK_DEFINE_NONDISP_HANDLE(VkDisplayModeKHR)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
++VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
+
+ #define VK_EXT_KHR_DISPLAY_REVISION 17
+ #define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 3
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 31f0231..a2b4c0f 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -36,18 +36,18 @@ namespace {
+ inline const DeviceVtbl& GetVtbl(VkQueue queue) {
+ return **reinterpret_cast<DeviceVtbl**>(queue);
+ }
+- inline const DeviceVtbl& GetVtbl(VkCmdBuffer cmdBuffer) {
+- return **reinterpret_cast<DeviceVtbl**>(cmdBuffer);
++ inline const DeviceVtbl& GetVtbl(VkCommandBuffer commandBuffer) {
++ return **reinterpret_cast<DeviceVtbl**>(commandBuffer);
+ }
+ } // namespace
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance) {
++VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
+ return vulkan::CreateInstance(pCreateInfo, pAllocator, pInstance);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator) {
++void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(instance).DestroyInstance(instance, pAllocator);
+ }
+
+@@ -97,12 +97,12 @@ void vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, V
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice) {
++VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
+ return GetVtbl(physicalDevice).CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator) {
++void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
+ vulkan::DestroyDevice(device, pAllocator);
+ }
+
+@@ -147,33 +147,33 @@ VkResult vkDeviceWaitIdle(VkDevice device) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem) {
+- return GetVtbl(device).AllocMemory(device, pAllocInfo, pAllocator, pMem);
++VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
++ return GetVtbl(device).AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+ }
+
+ __attribute__((visibility("default")))
+-void vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator) {
+- GetVtbl(device).FreeMemory(device, mem, pAllocator);
++void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
++ GetVtbl(device).FreeMemory(device, memory, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
+- return GetVtbl(device).MapMemory(device, mem, offset, size, flags, ppData);
++VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
++ return GetVtbl(device).MapMemory(device, memory, offset, size, flags, ppData);
+ }
+
+ __attribute__((visibility("default")))
+-void vkUnmapMemory(VkDevice device, VkDeviceMemory mem) {
+- GetVtbl(device).UnmapMemory(device, mem);
++void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
++ GetVtbl(device).UnmapMemory(device, memory);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
+- return GetVtbl(device).FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
++VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
++ return GetVtbl(device).FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
+- return GetVtbl(device).InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
++VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
++ return GetVtbl(device).InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+ }
+
+ __attribute__((visibility("default")))
+@@ -187,8 +187,8 @@ void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryReq
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) {
+- return GetVtbl(device).BindBufferMemory(device, buffer, mem, memOffset);
++VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
++ return GetVtbl(device).BindBufferMemory(device, buffer, memory, memoryOffset);
+ }
+
+ __attribute__((visibility("default")))
+@@ -197,8 +197,8 @@ void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequir
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset) {
+- return GetVtbl(device).BindImageMemory(device, image, mem, memOffset);
++VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
++ return GetVtbl(device).BindImageMemory(device, image, memory, memoryOffset);
+ }
+
+ __attribute__((visibility("default")))
+@@ -217,12 +217,12 @@ VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSp
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence) {
++VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+ return GetVtbl(device).CreateFence(device, pCreateInfo, pAllocator, pFence);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator) {
++void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyFence(device, fence, pAllocator);
+ }
+
+@@ -242,22 +242,22 @@ VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pF
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore) {
++VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
+ return GetVtbl(device).CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator) {
++void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroySemaphore(device, semaphore, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent) {
++VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
+ return GetVtbl(device).CreateEvent(device, pCreateInfo, pAllocator, pEvent);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator) {
++void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyEvent(device, event, pAllocator);
+ }
+
+@@ -277,12 +277,12 @@ VkResult vkResetEvent(VkDevice device, VkEvent event) {
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool) {
++VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
+ return GetVtbl(device).CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator) {
++void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyQueryPool(device, queryPool, pAllocator);
+ }
+
+@@ -292,32 +292,32 @@ VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer) {
++VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
+ return GetVtbl(device).CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator) {
++void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyBuffer(device, buffer, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView) {
++VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
+ return GetVtbl(device).CreateBufferView(device, pCreateInfo, pAllocator, pView);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator) {
++void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyBufferView(device, bufferView, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage) {
++VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
+ return GetVtbl(device).CreateImage(device, pCreateInfo, pAllocator, pImage);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator) {
++void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyImage(device, image, pAllocator);
+ }
+
+@@ -327,42 +327,42 @@ void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSu
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView) {
++VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
+ return GetVtbl(device).CreateImageView(device, pCreateInfo, pAllocator, pView);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator) {
++void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyImageView(device, imageView, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShaderModule) {
++VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
+ return GetVtbl(device).CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator) {
++void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyShaderModule(device, shaderModule, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader) {
++VkResult vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader) {
+ return GetVtbl(device).CreateShader(device, pCreateInfo, pAllocator, pShader);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator) {
++void vkDestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyShader(device, shader, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
++VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
+ return GetVtbl(device).CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator) {
++void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyPipelineCache(device, pipelineCache, pAllocator);
+ }
+
+@@ -372,62 +372,62 @@ VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
+- return GetVtbl(device).MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
++VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
++ return GetVtbl(device).MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) {
++VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+ return GetVtbl(device).CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) {
++VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+ return GetVtbl(device).CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator) {
++void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyPipeline(device, pipeline, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
++VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
+ return GetVtbl(device).CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator) {
++void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyPipelineLayout(device, pipelineLayout, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler) {
++VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
+ return GetVtbl(device).CreateSampler(device, pCreateInfo, pAllocator, pSampler);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator) {
++void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroySampler(device, sampler, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
++VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+ return GetVtbl(device).CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator) {
++void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
++VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
+ return GetVtbl(device).CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator) {
++void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyDescriptorPool(device, descriptorPool, pAllocator);
+ }
+
+@@ -437,8 +437,8 @@ VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkAllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets) {
+- return GetVtbl(device).AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
++VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
++ return GetVtbl(device).AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+ }
+
+ __attribute__((visibility("default")))
+@@ -452,22 +452,22 @@ void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, cons
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
++VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
+ return GetVtbl(device).CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator) {
++void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyFramebuffer(device, framebuffer, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass) {
++VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+ return GetVtbl(device).CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator) {
++void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyRenderPass(device, renderPass, pAllocator);
+ }
+
+@@ -477,263 +477,263 @@ void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExte
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool) {
+- return GetVtbl(device).CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
++VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
++ return GetVtbl(device).CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator) {
+- GetVtbl(device).DestroyCommandPool(device, cmdPool, pAllocator);
++void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
++ GetVtbl(device).DestroyCommandPool(device, commandPool, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) {
+- return GetVtbl(device).ResetCommandPool(device, cmdPool, flags);
++VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
++ return GetVtbl(device).ResetCommandPool(device, commandPool, flags);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkAllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers) {
+- return GetVtbl(device).AllocCommandBuffers(device, pAllocInfo, pCmdBuffers);
++VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
++ return GetVtbl(device).AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
+ }
+
+ __attribute__((visibility("default")))
+-void vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers) {
+- GetVtbl(device).FreeCommandBuffers(device, cmdPool, commandBufferCount, pCommandBuffers);
++void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
++ GetVtbl(device).FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) {
+- return GetVtbl(cmdBuffer).BeginCommandBuffer(cmdBuffer, pBeginInfo);
++VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
++ return GetVtbl(commandBuffer).BeginCommandBuffer(commandBuffer, pBeginInfo);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkEndCommandBuffer(VkCmdBuffer cmdBuffer) {
+- return GetVtbl(cmdBuffer).EndCommandBuffer(cmdBuffer);
++VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
++ return GetVtbl(commandBuffer).EndCommandBuffer(commandBuffer);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) {
+- return GetVtbl(cmdBuffer).ResetCommandBuffer(cmdBuffer, flags);
++VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
++ return GetVtbl(commandBuffer).ResetCommandBuffer(commandBuffer, flags);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+- GetVtbl(cmdBuffer).CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
++void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
++ GetVtbl(commandBuffer).CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
+- GetVtbl(cmdBuffer).CmdSetViewport(cmdBuffer, viewportCount, pViewports);
++void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
++ GetVtbl(commandBuffer).CmdSetViewport(commandBuffer, viewportCount, pViewports);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
+- GetVtbl(cmdBuffer).CmdSetScissor(cmdBuffer, scissorCount, pScissors);
++void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
++ GetVtbl(commandBuffer).CmdSetScissor(commandBuffer, scissorCount, pScissors);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth) {
+- GetVtbl(cmdBuffer).CmdSetLineWidth(cmdBuffer, lineWidth);
++void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
++ GetVtbl(commandBuffer).CmdSetLineWidth(commandBuffer, lineWidth);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
+- GetVtbl(cmdBuffer).CmdSetDepthBias(cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
++void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
++ GetVtbl(commandBuffer).CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConstants[4]) {
+- GetVtbl(cmdBuffer).CmdSetBlendConstants(cmdBuffer, blendConstants);
++void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
++ GetVtbl(commandBuffer).CmdSetBlendConstants(commandBuffer, blendConstants);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) {
+- GetVtbl(cmdBuffer).CmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds);
++void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
++ GetVtbl(commandBuffer).CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
+- GetVtbl(cmdBuffer).CmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask);
++void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
++ GetVtbl(commandBuffer).CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
+- GetVtbl(cmdBuffer).CmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask);
++void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
++ GetVtbl(commandBuffer).CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
+- GetVtbl(cmdBuffer).CmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
++void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
++ GetVtbl(commandBuffer).CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+- GetVtbl(cmdBuffer).CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
++void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
++ GetVtbl(commandBuffer).CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
+- GetVtbl(cmdBuffer).CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
++void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
++ GetVtbl(commandBuffer).CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
+- GetVtbl(cmdBuffer).CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
++void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
++ GetVtbl(commandBuffer).CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+- GetVtbl(cmdBuffer).CmdDraw(cmdBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
++void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
++ GetVtbl(commandBuffer).CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+- GetVtbl(cmdBuffer).CmdDrawIndexed(cmdBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
++void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
++ GetVtbl(commandBuffer).CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+- GetVtbl(cmdBuffer).CmdDrawIndirect(cmdBuffer, buffer, offset, drawCount, stride);
++void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
++ GetVtbl(commandBuffer).CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+- GetVtbl(cmdBuffer).CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, drawCount, stride);
++void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
++ GetVtbl(commandBuffer).CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
+- GetVtbl(cmdBuffer).CmdDispatch(cmdBuffer, x, y, z);
++void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
++ GetVtbl(commandBuffer).CmdDispatch(commandBuffer, x, y, z);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
+- GetVtbl(cmdBuffer).CmdDispatchIndirect(cmdBuffer, buffer, offset);
++void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
++ GetVtbl(commandBuffer).CmdDispatchIndirect(commandBuffer, buffer, offset);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
+- GetVtbl(cmdBuffer).CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
++void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
++ GetVtbl(commandBuffer).CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
+- GetVtbl(cmdBuffer).CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
++void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
++ GetVtbl(commandBuffer).CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+- GetVtbl(cmdBuffer).CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
++void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
++ GetVtbl(commandBuffer).CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+- GetVtbl(cmdBuffer).CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
++void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
++ GetVtbl(commandBuffer).CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+- GetVtbl(cmdBuffer).CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
++void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
++ GetVtbl(commandBuffer).CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) {
+- GetVtbl(cmdBuffer).CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
++void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) {
++ GetVtbl(commandBuffer).CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data) {
+- GetVtbl(cmdBuffer).CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
++void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
++ GetVtbl(commandBuffer).CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+- GetVtbl(cmdBuffer).CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
++void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
++ GetVtbl(commandBuffer).CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+- GetVtbl(cmdBuffer).CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
++void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
++ GetVtbl(commandBuffer).CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+- GetVtbl(cmdBuffer).CmdClearAttachments(cmdBuffer, attachmentCount, pAttachments, rectCount, pRects);
++void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
++ GetVtbl(commandBuffer).CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+- GetVtbl(cmdBuffer).CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
++void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
++ GetVtbl(commandBuffer).CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+- GetVtbl(cmdBuffer).CmdSetEvent(cmdBuffer, event, stageMask);
++void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
++ GetVtbl(commandBuffer).CmdSetEvent(commandBuffer, event, stageMask);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+- GetVtbl(cmdBuffer).CmdResetEvent(cmdBuffer, event, stageMask);
++void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
++ GetVtbl(commandBuffer).CmdResetEvent(commandBuffer, event, stageMask);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+- GetVtbl(cmdBuffer).CmdWaitEvents(cmdBuffer, eventCount, pEvents, srcStageMask, destStageMask, memBarrierCount, ppMemBarriers);
++void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) {
++ GetVtbl(commandBuffer).CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+- GetVtbl(cmdBuffer).CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, dependencyFlags, memBarrierCount, ppMemBarriers);
++void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) {
++ GetVtbl(commandBuffer).CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
+- GetVtbl(cmdBuffer).CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
++void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
++ GetVtbl(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, slot, flags);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
+- GetVtbl(cmdBuffer).CmdEndQuery(cmdBuffer, queryPool, slot);
++void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
++ GetVtbl(commandBuffer).CmdEndQuery(commandBuffer, queryPool, slot);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
+- GetVtbl(cmdBuffer).CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
++void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
++ GetVtbl(commandBuffer).CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
+- GetVtbl(cmdBuffer).CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
++void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
++ GetVtbl(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
+- GetVtbl(cmdBuffer).CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, stride, flags);
++void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
++ GetVtbl(commandBuffer).CmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) {
+- GetVtbl(cmdBuffer).CmdPushConstants(cmdBuffer, layout, stageFlags, offset, size, values);
++void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) {
++ GetVtbl(commandBuffer).CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, values);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
+- GetVtbl(cmdBuffer).CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
++void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
++ GetVtbl(commandBuffer).CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents) {
+- GetVtbl(cmdBuffer).CmdNextSubpass(cmdBuffer, contents);
++void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkRenderPassContents contents) {
++ GetVtbl(commandBuffer).CmdNextSubpass(commandBuffer, contents);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdEndRenderPass(VkCmdBuffer cmdBuffer) {
+- GetVtbl(cmdBuffer).CmdEndRenderPass(cmdBuffer);
++void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
++ GetVtbl(commandBuffer).CmdEndRenderPass(commandBuffer);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) {
+- GetVtbl(cmdBuffer).CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
++void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers) {
++ GetVtbl(commandBuffer).CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/libvulkan/entry.cpp.tmpl b/vulkan/libvulkan/entry.cpp.tmpl
+index d0e665f..5aed3df 100644
+--- a/vulkan/libvulkan/entry.cpp.tmpl
++++ b/vulkan/libvulkan/entry.cpp.tmpl
+@@ -63,8 +63,8 @@ namespace {
+ inline const DeviceVtbl& GetVtbl(VkQueue queue) {
+ return **reinterpret_cast<DeviceVtbl**>(queue);
+ }
+- inline const DeviceVtbl& GetVtbl(VkCmdBuffer cmdBuffer) {
+- return **reinterpret_cast<DeviceVtbl**>(cmdBuffer);
++ inline const DeviceVtbl& GetVtbl(VkCommandBuffer commandBuffer) {
++ return **reinterpret_cast<DeviceVtbl**>(commandBuffer);
+ }
+ } // namespace
+ ¶
+@@ -159,7 +159,7 @@ namespace {
+ {{define "Dispatch#VkPhysicalDevice"}}GetVtbl({{$.Node.Name}}).{{end}}
+ {{define "Dispatch#VkDevice" }}GetVtbl({{$.Node.Name}}).{{end}}
+ {{define "Dispatch#VkQueue" }}GetVtbl({{$.Node.Name}}).{{end}}
+-{{define "Dispatch#VkCmdBuffer" }}GetVtbl({{$.Node.Name}}).{{end}}
++{{define "Dispatch#VkCommandBuffer" }}GetVtbl({{$.Node.Name}}).{{end}}
+ {{define "Dispatch_Default" }}vulkan::{{end}}
+ {{define "Dispatch"}}
+ {{AssertType $ "Function"}}
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
+index 4e08015..f6a6510 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp
++++ b/vulkan/libvulkan/get_proc_addr.cpp
+@@ -74,9 +74,9 @@ const NameProcEntry kInstanceProcTbl[] = {
+ const NameProcEntry kDeviceProcTbl[] = {
+ // clang-format off
+ {"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR)},
+- {"vkAllocCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkAllocCommandBuffers)},
+- {"vkAllocDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkAllocDescriptorSets)},
+- {"vkAllocMemory", reinterpret_cast<PFN_vkVoidFunction>(vkAllocMemory)},
++ {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateCommandBuffers)},
++ {"vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateDescriptorSets)},
++ {"vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateMemory)},
+ {"vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkBeginCommandBuffer)},
+ {"vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory)},
+ {"vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory)},
+@@ -231,9 +231,9 @@ const NameOffsetEntry kInstanceOffsetTbl[] = {
+ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ // clang-format off
+ {"vkAcquireNextImageKHR", offsetof(DeviceVtbl, AcquireNextImageKHR)},
+- {"vkAllocCommandBuffers", offsetof(DeviceVtbl, AllocCommandBuffers)},
+- {"vkAllocDescriptorSets", offsetof(DeviceVtbl, AllocDescriptorSets)},
+- {"vkAllocMemory", offsetof(DeviceVtbl, AllocMemory)},
++ {"vkAllocateCommandBuffers", offsetof(DeviceVtbl, AllocateCommandBuffers)},
++ {"vkAllocateDescriptorSets", offsetof(DeviceVtbl, AllocateDescriptorSets)},
++ {"vkAllocateMemory", offsetof(DeviceVtbl, AllocateMemory)},
+ {"vkBeginCommandBuffer", offsetof(DeviceVtbl, BeginCommandBuffer)},
+ {"vkBindBufferMemory", offsetof(DeviceVtbl, BindBufferMemory)},
+ {"vkBindImageMemory", offsetof(DeviceVtbl, BindImageMemory)},
+@@ -530,9 +530,9 @@ bool LoadDeviceVtbl(VkDevice device,
+ ALOGE("missing device proc: %s", "vkDeviceWaitIdle");
+ success = false;
+ }
+- vtbl.AllocMemory = reinterpret_cast<PFN_vkAllocMemory>(get_proc_addr(device, "vkAllocMemory"));
+- if (UNLIKELY(!vtbl.AllocMemory)) {
+- ALOGE("missing device proc: %s", "vkAllocMemory");
++ vtbl.AllocateMemory = reinterpret_cast<PFN_vkAllocateMemory>(get_proc_addr(device, "vkAllocateMemory"));
++ if (UNLIKELY(!vtbl.AllocateMemory)) {
++ ALOGE("missing device proc: %s", "vkAllocateMemory");
+ success = false;
+ }
+ vtbl.FreeMemory = reinterpret_cast<PFN_vkFreeMemory>(get_proc_addr(device, "vkFreeMemory"));
+@@ -815,9 +815,9 @@ bool LoadDeviceVtbl(VkDevice device,
+ ALOGE("missing device proc: %s", "vkResetDescriptorPool");
+ success = false;
+ }
+- vtbl.AllocDescriptorSets = reinterpret_cast<PFN_vkAllocDescriptorSets>(get_proc_addr(device, "vkAllocDescriptorSets"));
+- if (UNLIKELY(!vtbl.AllocDescriptorSets)) {
+- ALOGE("missing device proc: %s", "vkAllocDescriptorSets");
++ vtbl.AllocateDescriptorSets = reinterpret_cast<PFN_vkAllocateDescriptorSets>(get_proc_addr(device, "vkAllocateDescriptorSets"));
++ if (UNLIKELY(!vtbl.AllocateDescriptorSets)) {
++ ALOGE("missing device proc: %s", "vkAllocateDescriptorSets");
+ success = false;
+ }
+ vtbl.FreeDescriptorSets = reinterpret_cast<PFN_vkFreeDescriptorSets>(get_proc_addr(device, "vkFreeDescriptorSets"));
+@@ -870,9 +870,9 @@ bool LoadDeviceVtbl(VkDevice device,
+ ALOGE("missing device proc: %s", "vkResetCommandPool");
+ success = false;
+ }
+- vtbl.AllocCommandBuffers = reinterpret_cast<PFN_vkAllocCommandBuffers>(get_proc_addr(device, "vkAllocCommandBuffers"));
+- if (UNLIKELY(!vtbl.AllocCommandBuffers)) {
+- ALOGE("missing device proc: %s", "vkAllocCommandBuffers");
++ vtbl.AllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(get_proc_addr(device, "vkAllocateCommandBuffers"));
++ if (UNLIKELY(!vtbl.AllocateCommandBuffers)) {
++ ALOGE("missing device proc: %s", "vkAllocateCommandBuffers");
+ success = false;
+ }
+ vtbl.FreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(get_proc_addr(device, "vkFreeCommandBuffers"));
+diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
+index 4e68f88..246c37d 100644
+--- a/vulkan/libvulkan/loader.cpp
++++ b/vulkan/libvulkan/loader.cpp
+@@ -58,10 +58,10 @@ typedef struct VkLayerLinkedListElem_ {
+ // Define Handle typedef to be void* as returned from dlopen.
+ typedef void* SharedLibraryHandle;
+
+-// Standard-library allocator that delegates to VkAllocCallbacks.
++// Standard-library allocator that delegates to VkAllocationCallbacks.
+ //
+ // TODO(jessehall): This class currently always uses
+-// VK_SYSTEM_ALLOC_SCOPE_INSTANCE. The scope to use could be a template
++// VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE. The scope to use could be a template
+ // parameter or a constructor parameter. The former would help catch bugs
+ // where we use the wrong scope, e.g. adding a command-scope string to an
+ // instance-scope vector. But that might also be pretty annoying to deal with.
+@@ -70,7 +70,7 @@ class CallbackAllocator {
+ public:
+ typedef T value_type;
+
+- CallbackAllocator(const VkAllocCallbacks* alloc_input)
++ CallbackAllocator(const VkAllocationCallbacks* alloc_input)
+ : alloc(alloc_input) {}
+
+ template <class T2>
+@@ -78,8 +78,9 @@ class CallbackAllocator {
+ : alloc(other.alloc) {}
+
+ T* allocate(std::size_t n) {
+- void* mem = alloc->pfnAlloc(alloc->pUserData, n * sizeof(T), alignof(T),
+- VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
++ void* mem =
++ alloc->pfnAllocation(alloc->pUserData, n * sizeof(T), alignof(T),
++ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ return static_cast<T*>(mem);
+ }
+
+@@ -87,7 +88,7 @@ class CallbackAllocator {
+ alloc->pfnFree(alloc->pUserData, array);
+ }
+
+- const VkAllocCallbacks* alloc;
++ const VkAllocationCallbacks* alloc;
+ };
+ // These are needed in order to move Strings
+ template <class T>
+@@ -136,7 +137,7 @@ typedef UnorderedMap<String, LayerData>::iterator LayerMapIterator;
+ } // namespace
+
+ struct VkInstance_T {
+- VkInstance_T(const VkAllocCallbacks* alloc_callbacks)
++ VkInstance_T(const VkAllocationCallbacks* alloc_callbacks)
+ : vtbl(&vtbl_storage),
+ alloc(alloc_callbacks),
+ num_physical_devices(0),
+@@ -155,7 +156,7 @@ struct VkInstance_T {
+ InstanceVtbl* vtbl;
+ InstanceVtbl vtbl_storage;
+
+- const VkAllocCallbacks* alloc;
++ const VkAllocationCallbacks* alloc;
+ uint32_t num_physical_devices;
+ VkPhysicalDevice physical_devices[kMaxPhysicalDevices];
+
+@@ -214,16 +215,19 @@ inline const DeviceVtbl* GetVtbl(VkQueue queue) {
+ return *reinterpret_cast<DeviceVtbl**>(queue);
+ }
+
+-void* DefaultAlloc(void*, size_t size, size_t alignment, VkSystemAllocScope) {
++void* DefaultAllocate(void*,
++ size_t size,
++ size_t alignment,
++ VkSystemAllocationScope) {
+ void* ptr = nullptr;
+ return posix_memalign(&ptr, alignment, size) == 0 ? ptr : nullptr;
+ }
+
+-void* DefaultRealloc(void*,
+- void* ptr,
+- size_t size,
+- size_t alignment,
+- VkSystemAllocScope) {
++void* DefaultReallocate(void*,
++ void* ptr,
++ size_t size,
++ size_t alignment,
++ VkSystemAllocationScope) {
+ if (size == 0) {
+ free(ptr);
+ return nullptr;
+@@ -253,10 +257,10 @@ void DefaultFree(void*, void* pMem) {
+ free(pMem);
+ }
+
+-const VkAllocCallbacks kDefaultAllocCallbacks = {
++const VkAllocationCallbacks kDefaultAllocCallbacks = {
+ .pUserData = nullptr,
+- .pfnAlloc = DefaultAlloc,
+- .pfnRealloc = DefaultRealloc,
++ .pfnAllocation = DefaultAllocate,
++ .pfnReallocation = DefaultReallocate,
+ .pfnFree = DefaultFree,
+ };
+
+@@ -289,7 +293,7 @@ bool EnsureInitialized() {
+ }
+
+ void DestroyDevice(Device* device) {
+- const VkAllocCallbacks* alloc = device->instance->alloc;
++ const VkAllocationCallbacks* alloc = device->instance->alloc;
+ device->~Device();
+ alloc->pfnFree(alloc->pUserData, device);
+ }
+@@ -476,7 +480,7 @@ VkResult ActivateAllLayers(TInfo create_info, Instance* instance, TObject* objec
+ template <class TCreateInfo>
+ bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
+ const char* extension_name,
+- const VkAllocCallbacks* alloc) {
++ const VkAllocationCallbacks* alloc) {
+ for (uint32_t i = 0; i < local_create_info.enabledExtensionNameCount; ++i) {
+ if (!strcmp(extension_name,
+ local_create_info.ppEnabledExtensionNames[i])) {
+@@ -485,10 +489,10 @@ bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
+ }
+ uint32_t extension_count = local_create_info.enabledExtensionNameCount;
+ local_create_info.enabledExtensionNameCount++;
+- void* mem = alloc->pfnAlloc(
++ void* mem = alloc->pfnAllocation(
+ alloc->pUserData,
+ local_create_info.enabledExtensionNameCount * sizeof(char*),
+- alignof(char*), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
++ alignof(char*), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ if (mem) {
+ const char** enabled_extensions = static_cast<const char**>(mem);
+ for (uint32_t i = 0; i < extension_count; ++i) {
+@@ -508,7 +512,7 @@ bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
+
+ template <class T>
+ void FreeAllocatedCreateInfo(T& local_create_info,
+- const VkAllocCallbacks* alloc) {
++ const VkAllocationCallbacks* alloc) {
+ alloc->pfnFree(
+ alloc->pUserData,
+ const_cast<char**>(local_create_info.ppEnabledExtensionNames));
+@@ -568,7 +572,7 @@ PFN_vkVoidFunction GetLayerDeviceProcAddr(VkDevice device, const char* name) {
+ // chain.
+
+ void DestroyInstanceBottom(VkInstance instance,
+- const VkAllocCallbacks* allocator) {
++ const VkAllocationCallbacks* allocator) {
+ // These checks allow us to call DestroyInstanceBottom from any error path
+ // in CreateInstanceBottom, before the driver instance is fully initialized.
+ if (instance->drv.vtbl.instance != VK_NULL_HANDLE &&
+@@ -587,13 +591,13 @@ void DestroyInstanceBottom(VkInstance instance,
+ it != instance->active_layers.end(); ++it) {
+ DeactivateLayer(instance, it);
+ }
+- const VkAllocCallbacks* alloc = instance->alloc;
++ const VkAllocationCallbacks* alloc = instance->alloc;
+ instance->~VkInstance_T();
+ alloc->pfnFree(alloc->pUserData, instance);
+ }
+
+ VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
+- const VkAllocCallbacks* allocator,
++ const VkAllocationCallbacks* allocator,
+ VkInstance* instance_ptr) {
+ Instance* instance = *instance_ptr;
+ VkResult result;
+@@ -729,7 +733,7 @@ void GetPhysicalDeviceMemoryPropertiesBottom(
+
+ VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
+ const VkDeviceCreateInfo* create_info,
+- const VkAllocCallbacks* allocator,
++ const VkAllocationCallbacks* allocator,
+ VkDevice* out_device) {
+ Instance& instance = *static_cast<Instance*>(GetVtbl(pdev)->instance);
+ VkResult result;
+@@ -741,9 +745,9 @@ VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
+ allocator = &kDefaultAllocCallbacks;
+ }
+
+- void* mem =
+- allocator->pfnAlloc(allocator->pUserData, sizeof(Device),
+- alignof(Device), VK_SYSTEM_ALLOC_SCOPE_DEVICE);
++ void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Device),
++ alignof(Device),
++ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
+ if (!mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ Device* device = new (mem) Device(&instance);
+@@ -941,7 +945,7 @@ VkResult EnumerateInstanceLayerProperties(uint32_t* count,
+ }
+
+ VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+- const VkAllocCallbacks* allocator,
++ const VkAllocationCallbacks* allocator,
+ VkInstance* out_instance) {
+ VkResult result;
+
+@@ -954,9 +958,9 @@ VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+ VkInstanceCreateInfo local_create_info = *create_info;
+ create_info = &local_create_info;
+
+- void* instance_mem =
+- allocator->pfnAlloc(allocator->pUserData, sizeof(Instance),
+- alignof(Instance), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
++ void* instance_mem = allocator->pfnAllocation(
++ allocator->pUserData, sizeof(Instance), alignof(Instance),
++ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ if (!instance_mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ Instance* instance = new (instance_mem) Instance(allocator);
+@@ -1121,17 +1125,17 @@ void GetDeviceQueue(VkDevice drv_device,
+ }
+
+ VkResult AllocCommandBuffers(VkDevice device,
+- const VkCmdBufferAllocInfo* alloc_info,
+- VkCmdBuffer* cmdbuffers) {
++ const VkCommandBufferAllocateInfo* alloc_info,
++ VkCommandBuffer* cmdbufs) {
+ const DeviceVtbl* vtbl = GetVtbl(device);
+- VkResult result = vtbl->AllocCommandBuffers(device, alloc_info, cmdbuffers);
++ VkResult result = vtbl->AllocateCommandBuffers(device, alloc_info, cmdbufs);
+ if (result != VK_SUCCESS)
+ return result;
+ for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
+ hwvulkan_dispatch_t* dispatch =
+- reinterpret_cast<hwvulkan_dispatch_t*>(cmdbuffers[i]);
++ reinterpret_cast<hwvulkan_dispatch_t*>(cmdbufs[i]);
+ ALOGE_IF(dispatch->magic != HWVULKAN_DISPATCH_MAGIC,
+- "invalid VkCmdBuffer dispatch magic: 0x%" PRIxPTR,
++ "invalid VkCommandBuffer dispatch magic: 0x%" PRIxPTR,
+ dispatch->magic);
+ dispatch->vtbl = vtbl;
+ }
+@@ -1139,7 +1143,7 @@ VkResult AllocCommandBuffers(VkDevice device,
+ }
+
+ VkResult DestroyDevice(VkDevice drv_device,
+- const VkAllocCallbacks* /*allocator*/) {
++ const VkAllocationCallbacks* /*allocator*/) {
+ const DeviceVtbl* vtbl = GetVtbl(drv_device);
+ Device* device = static_cast<Device*>(vtbl->device);
+ for (auto it = device->active_layers.begin();
+@@ -1154,27 +1158,27 @@ VkResult DestroyDevice(VkDevice drv_device,
+ void* AllocMem(VkInstance instance,
+ size_t size,
+ size_t align,
+- VkSystemAllocScope scope) {
+- const VkAllocCallbacks* alloc_cb = instance->alloc;
+- return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, scope);
++ VkSystemAllocationScope scope) {
++ const VkAllocationCallbacks* alloc_cb = instance->alloc;
++ return alloc_cb->pfnAllocation(alloc_cb->pUserData, size, align, scope);
+ }
+
+ void FreeMem(VkInstance instance, void* ptr) {
+- const VkAllocCallbacks* alloc_cb = instance->alloc;
++ const VkAllocationCallbacks* alloc_cb = instance->alloc;
+ alloc_cb->pfnFree(alloc_cb->pUserData, ptr);
+ }
+
+ void* AllocMem(VkDevice device,
+ size_t size,
+ size_t align,
+- VkSystemAllocScope scope) {
+- const VkAllocCallbacks* alloc_cb =
++ VkSystemAllocationScope scope) {
++ const VkAllocationCallbacks* alloc_cb =
+ static_cast<Device*>(GetVtbl(device)->device)->instance->alloc;
+- return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, scope);
++ return alloc_cb->pfnAllocation(alloc_cb->pUserData, size, align, scope);
+ }
+
+ void FreeMem(VkDevice device, void* ptr) {
+- const VkAllocCallbacks* alloc_cb =
++ const VkAllocationCallbacks* alloc_cb =
+ static_cast<Device*>(GetVtbl(device)->device)->instance->alloc;
+ alloc_cb->pfnFree(alloc_cb->pUserData, ptr);
+ }
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index b6c8552..bf71c8f 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -67,7 +67,7 @@ struct DeviceVtbl {
+ PFN_vkDestroyDevice DestroyDevice;
+ PFN_vkGetDeviceQueue GetDeviceQueue;
+ PFN_vkDeviceWaitIdle DeviceWaitIdle;
+- PFN_vkAllocMemory AllocMemory;
++ PFN_vkAllocateMemory AllocateMemory;
+ PFN_vkFreeMemory FreeMemory;
+ PFN_vkMapMemory MapMemory;
+ PFN_vkUnmapMemory UnmapMemory;
+@@ -123,7 +123,7 @@ struct DeviceVtbl {
+ PFN_vkCreateDescriptorPool CreateDescriptorPool;
+ PFN_vkDestroyDescriptorPool DestroyDescriptorPool;
+ PFN_vkResetDescriptorPool ResetDescriptorPool;
+- PFN_vkAllocDescriptorSets AllocDescriptorSets;
++ PFN_vkAllocateDescriptorSets AllocateDescriptorSets;
+ PFN_vkFreeDescriptorSets FreeDescriptorSets;
+ PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
+ PFN_vkCreateFramebuffer CreateFramebuffer;
+@@ -134,7 +134,7 @@ struct DeviceVtbl {
+ PFN_vkCreateCommandPool CreateCommandPool;
+ PFN_vkDestroyCommandPool DestroyCommandPool;
+ PFN_vkResetCommandPool ResetCommandPool;
+- PFN_vkAllocCommandBuffers AllocCommandBuffers;
++ PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
+ PFN_vkFreeCommandBuffers FreeCommandBuffers;
+
+ PFN_vkQueueSubmit QueueSubmit;
+@@ -214,7 +214,7 @@ VkResult EnumerateInstanceExtensionProperties(
+ VkResult EnumerateInstanceLayerProperties(uint32_t* count,
+ VkLayerProperties* properties);
+ VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+- const VkAllocCallbacks* pAllocator,
++ const VkAllocationCallbacks* pAllocator,
+ VkInstance* instance);
+ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name);
+ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice drv_device, const char* name);
+@@ -223,19 +223,20 @@ void GetDeviceQueue(VkDevice drv_device,
+ uint32_t index,
+ VkQueue* out_queue);
+ VkResult AllocCommandBuffers(VkDevice device,
+- const VkCmdBufferAllocInfo* alloc_info,
+- VkCmdBuffer* cmdbuffers);
+-VkResult DestroyDevice(VkDevice drv_device, const VkAllocCallbacks* pAllocator);
++ const VkCommandBufferAllocateInfo* alloc_info,
++ VkCommandBuffer* cmdbufs);
++VkResult DestroyDevice(VkDevice drv_device,
++ const VkAllocationCallbacks* pAllocator);
+
+ void* AllocMem(VkInstance instance,
+ size_t size,
+ size_t align,
+- VkSystemAllocScope scope);
++ VkSystemAllocationScope scope);
+ void FreeMem(VkInstance instance, void* ptr);
+ void* AllocMem(VkDevice device,
+ size_t size,
+ size_t align,
+- VkSystemAllocScope scope);
++ VkSystemAllocationScope scope);
+ void FreeMem(VkDevice device, void* ptr);
+ const DeviceVtbl& GetDriverVtbl(VkDevice device);
+ const DeviceVtbl& GetDriverVtbl(VkQueue queue);
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index f1fe236..5b35506 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -37,7 +37,8 @@ namespace {
+ // ----------------------------------------------------------------------------
+ // These functions/classes form an adaptor that allows objects to be refcounted
+ // by both android::sp<> and std::shared_ptr<> simultaneously, and delegates
+-// allocation of the shared_ptr<> control structure to VkAllocCallbacks. The
++// allocation of the shared_ptr<> control structure to VkAllocationCallbacks.
++// The
+ // platform holds a reference to the ANativeWindow using its embedded reference
+ // count, and the ANativeWindow implementation holds references to the
+ // ANativeWindowBuffers using their embedded reference counts, so the
+@@ -54,12 +55,14 @@ struct AllocScope {};
+
+ template <>
+ struct AllocScope<VkInstance> {
+- static const VkSystemAllocScope kScope = VK_SYSTEM_ALLOC_SCOPE_INSTANCE;
++ static const VkSystemAllocationScope kScope =
++ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE;
+ };
+
+ template <>
+ struct AllocScope<VkDevice> {
+- static const VkSystemAllocScope kScope = VK_SYSTEM_ALLOC_SCOPE_DEVICE;
++ static const VkSystemAllocationScope kScope =
++ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE;
+ };
+
+ template <typename T, typename Host>
+@@ -142,7 +145,7 @@ VkResult CreateAndroidSurfaceKHR(VkInstance instance,
+ ANativeWindow* window,
+ VkSurfaceKHR* out_surface) {
+ void* mem = AllocMem(instance, sizeof(Surface), alignof(Surface),
+- VK_SYSTEM_ALLOC_SCOPE_OBJECT);
++ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ if (!mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ Surface* surface = new (mem) Surface;
+@@ -231,9 +234,9 @@ VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ // - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT: definitely not
+ // - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: definitely not
+ capabilities->supportedUsageFlags =
+- VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT |
+- VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
+- VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
++ VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
++ VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
++ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+ VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+
+ return VK_SUCCESS;
+@@ -378,7 +381,7 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ // After this point, we must deallocate the swapchain on error.
+
+ void* mem = AllocMem(device, sizeof(Swapchain), alignof(Swapchain),
+- VK_SYSTEM_ALLOC_SCOPE_OBJECT);
++ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ if (!mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ Swapchain* swapchain = new (mem) Swapchain(surface, num_images);
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 698dbd0..d134c0e 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -35,7 +35,7 @@ struct VkPhysicalDevice_T {
+
+ struct VkInstance_T {
+ hwvulkan_dispatch_t dispatch;
+- VkAllocCallbacks allocator;
++ VkAllocationCallbacks allocator;
+ VkPhysicalDevice_T physical_device;
+ };
+
+@@ -43,7 +43,7 @@ struct VkQueue_T {
+ hwvulkan_dispatch_t dispatch;
+ };
+
+-struct VkCmdBuffer_T {
++struct VkCommandBuffer_T {
+ hwvulkan_dispatch_t dispatch;
+ };
+
+@@ -95,7 +95,7 @@ const VkDeviceSize kMaxDeviceMemory = VkDeviceSize(INTPTR_MAX) + 1;
+
+ struct VkDevice_T {
+ hwvulkan_dispatch_t dispatch;
+- VkAllocCallbacks allocator;
++ VkAllocationCallbacks allocator;
+ VkInstance_T* instance;
+ VkQueue_T queue;
+ std::array<uint64_t, HandleType::kNumTypes> next_handle;
+@@ -131,16 +131,17 @@ __attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = {
+ namespace {
+
+ VkResult CreateInstance(const VkInstanceCreateInfo* /*create_info*/,
+- const VkAllocCallbacks* allocator,
++ const VkAllocationCallbacks* allocator,
+ VkInstance* out_instance) {
+ // Assume the loader provided alloc callbacks even if the app didn't.
+ ALOG_ASSERT(
+ allocator,
+ "Missing alloc callbacks, loader or app should have provided them");
+
+- VkInstance_T* instance = static_cast<VkInstance_T*>(allocator->pfnAlloc(
+- allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
+- VK_SYSTEM_ALLOC_SCOPE_INSTANCE));
++ VkInstance_T* instance =
++ static_cast<VkInstance_T*>(allocator->pfnAllocation(
++ allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
++ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE));
+ if (!instance)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+@@ -245,7 +246,7 @@ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) {
+ // Instance
+
+ void DestroyInstance(VkInstance instance,
+- const VkAllocCallbacks* /*allocator*/) {
++ const VkAllocationCallbacks* /*allocator*/) {
+ instance->allocator.pfnFree(instance->allocator.pUserData, instance);
+ }
+
+@@ -303,14 +304,14 @@ void GetPhysicalDeviceMemoryProperties(
+
+ VkResult CreateDevice(VkPhysicalDevice physical_device,
+ const VkDeviceCreateInfo*,
+- const VkAllocCallbacks* allocator,
++ const VkAllocationCallbacks* allocator,
+ VkDevice* out_device) {
+ VkInstance_T* instance = GetInstanceFromPhysicalDevice(physical_device);
+ if (!allocator)
+ allocator = &instance->allocator;
+- VkDevice_T* device = static_cast<VkDevice_T*>(
+- allocator->pfnAlloc(allocator->pUserData, sizeof(VkDevice_T),
+- alignof(VkDevice_T), VK_SYSTEM_ALLOC_SCOPE_DEVICE));
++ VkDevice_T* device = static_cast<VkDevice_T*>(allocator->pfnAllocation(
++ allocator->pUserData, sizeof(VkDevice_T), alignof(VkDevice_T),
++ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE));
+ if (!device)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+@@ -325,7 +326,8 @@ VkResult CreateDevice(VkPhysicalDevice physical_device,
+ return VK_SUCCESS;
+ }
+
+-void DestroyDevice(VkDevice device, const VkAllocCallbacks* /*allocator*/) {
++void DestroyDevice(VkDevice device,
++ const VkAllocationCallbacks* /*allocator*/) {
+ if (!device)
+ return;
+ device->allocator.pfnFree(device->allocator.pUserData, device);
+@@ -336,50 +338,51 @@ void GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
+ }
+
+ // -----------------------------------------------------------------------------
+-// CmdPool
++// CommandPool
+
+-struct CmdPool {
+- typedef VkCmdPool HandleType;
+- VkAllocCallbacks allocator;
++struct CommandPool {
++ typedef VkCommandPool HandleType;
++ VkAllocationCallbacks allocator;
+ };
+-DEFINE_OBJECT_HANDLE_CONVERSION(CmdPool)
++DEFINE_OBJECT_HANDLE_CONVERSION(CommandPool)
+
+ VkResult CreateCommandPool(VkDevice device,
+- const VkCmdPoolCreateInfo* /*create_info*/,
+- const VkAllocCallbacks* allocator,
+- VkCmdPool* cmd_pool) {
++ const VkCommandPoolCreateInfo* /*create_info*/,
++ const VkAllocationCallbacks* allocator,
++ VkCommandPool* cmd_pool) {
+ if (!allocator)
+ allocator = &device->allocator;
+- CmdPool* pool = static_cast<CmdPool*>(
+- allocator->pfnAlloc(allocator->pUserData, sizeof(CmdPool),
+- alignof(CmdPool), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
++ CommandPool* pool = static_cast<CommandPool*>(allocator->pfnAllocation(
++ allocator->pUserData, sizeof(CommandPool), alignof(CommandPool),
++ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
+ if (!pool)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ pool->allocator = *allocator;
+- *cmd_pool = GetHandleToCmdPool(pool);
++ *cmd_pool = GetHandleToCommandPool(pool);
+ return VK_SUCCESS;
+ }
+
+ void DestroyCommandPool(VkDevice /*device*/,
+- VkCmdPool cmd_pool,
+- const VkAllocCallbacks* /*allocator*/) {
+- CmdPool* pool = GetCmdPoolFromHandle(cmd_pool);
++ VkCommandPool cmd_pool,
++ const VkAllocationCallbacks* /*allocator*/) {
++ CommandPool* pool = GetCommandPoolFromHandle(cmd_pool);
+ pool->allocator.pfnFree(pool->allocator.pUserData, pool);
+ }
+
+ // -----------------------------------------------------------------------------
+ // CmdBuffer
+
+-VkResult AllocCommandBuffers(VkDevice /*device*/,
+- const VkCmdBufferAllocInfo* alloc_info,
+- VkCmdBuffer* cmdbufs) {
++VkResult AllocateCommandBuffers(VkDevice /*device*/,
++ const VkCommandBufferAllocateInfo* alloc_info,
++ VkCommandBuffer* cmdbufs) {
+ VkResult result = VK_SUCCESS;
+- CmdPool& pool = *GetCmdPoolFromHandle(alloc_info->cmdPool);
++ CommandPool& pool = *GetCommandPoolFromHandle(alloc_info->commandPool);
+ std::fill(cmdbufs, cmdbufs + alloc_info->bufferCount, nullptr);
+ for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
+- cmdbufs[i] = static_cast<VkCmdBuffer_T*>(pool.allocator.pfnAlloc(
+- pool.allocator.pUserData, sizeof(VkCmdBuffer_T),
+- alignof(VkCmdBuffer_T), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
++ cmdbufs[i] =
++ static_cast<VkCommandBuffer_T*>(pool.allocator.pfnAllocation(
++ pool.allocator.pUserData, sizeof(VkCommandBuffer_T),
++ alignof(VkCommandBuffer_T), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
+ if (!cmdbufs[i]) {
+ result = VK_ERROR_OUT_OF_HOST_MEMORY;
+ break;
+@@ -397,10 +400,10 @@ VkResult AllocCommandBuffers(VkDevice /*device*/,
+ }
+
+ void FreeCommandBuffers(VkDevice /*device*/,
+- VkCmdPool cmd_pool,
++ VkCommandPool cmd_pool,
+ uint32_t count,
+- const VkCmdBuffer* cmdbufs) {
+- CmdPool& pool = *GetCmdPoolFromHandle(cmd_pool);
++ const VkCommandBuffer* cmdbufs) {
++ CommandPool& pool = *GetCommandPoolFromHandle(cmd_pool);
+ for (uint32_t i = 0; i < count; i++)
+ pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
+ }
+@@ -415,19 +418,19 @@ struct DeviceMemory {
+ };
+ DEFINE_OBJECT_HANDLE_CONVERSION(DeviceMemory)
+
+-VkResult AllocMemory(VkDevice device,
+- const VkMemoryAllocInfo* alloc_info,
+- const VkAllocCallbacks* allocator,
+- VkDeviceMemory* mem_handle) {
++VkResult AllocateMemory(VkDevice device,
++ const VkMemoryAllocateInfo* alloc_info,
++ const VkAllocationCallbacks* allocator,
++ VkDeviceMemory* mem_handle) {
+ if (SIZE_MAX - sizeof(DeviceMemory) <= alloc_info->allocationSize)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ if (!allocator)
+ allocator = &device->allocator;
+
+ size_t size = sizeof(DeviceMemory) + size_t(alloc_info->allocationSize);
+- DeviceMemory* mem = static_cast<DeviceMemory*>(
+- allocator->pfnAlloc(allocator->pUserData, size, alignof(DeviceMemory),
+- VK_SYSTEM_ALLOC_SCOPE_OBJECT));
++ DeviceMemory* mem = static_cast<DeviceMemory*>(allocator->pfnAllocation(
++ allocator->pUserData, size, alignof(DeviceMemory),
++ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
+ if (!mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ mem->size = size;
+@@ -437,7 +440,7 @@ VkResult AllocMemory(VkDevice device,
+
+ void FreeMemory(VkDevice device,
+ VkDeviceMemory mem_handle,
+- const VkAllocCallbacks* allocator) {
++ const VkAllocationCallbacks* allocator) {
+ if (!allocator)
+ allocator = &device->allocator;
+ DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
+@@ -466,7 +469,7 @@ DEFINE_OBJECT_HANDLE_CONVERSION(Buffer)
+
+ VkResult CreateBuffer(VkDevice device,
+ const VkBufferCreateInfo* create_info,
+- const VkAllocCallbacks* allocator,
++ const VkAllocationCallbacks* allocator,
+ VkBuffer* buffer_handle) {
+ ALOGW_IF(create_info->size > kMaxDeviceMemory,
+ "CreateBuffer: requested size 0x%" PRIx64
+@@ -474,9 +477,9 @@ VkResult CreateBuffer(VkDevice device,
+ create_info->size, kMaxDeviceMemory);
+ if (!allocator)
+ allocator = &device->allocator;
+- Buffer* buffer = static_cast<Buffer*>(
+- allocator->pfnAlloc(allocator->pUserData, sizeof(Buffer),
+- alignof(Buffer), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
++ Buffer* buffer = static_cast<Buffer*>(allocator->pfnAllocation(
++ allocator->pUserData, sizeof(Buffer), alignof(Buffer),
++ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
+ if (!buffer)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ buffer->size = create_info->size;
+@@ -495,7 +498,7 @@ void GetBufferMemoryRequirements(VkDevice,
+
+ void DestroyBuffer(VkDevice device,
+ VkBuffer buffer_handle,
+- const VkAllocCallbacks* allocator) {
++ const VkAllocationCallbacks* allocator) {
+ if (!allocator)
+ allocator = &device->allocator;
+ Buffer* buffer = GetBufferFromHandle(buffer_handle);
+@@ -513,7 +516,7 @@ DEFINE_OBJECT_HANDLE_CONVERSION(Image)
+
+ VkResult CreateImage(VkDevice device,
+ const VkImageCreateInfo* create_info,
+- const VkAllocCallbacks* allocator,
++ const VkAllocationCallbacks* allocator,
+ VkImage* image_handle) {
+ if (create_info->imageType != VK_IMAGE_TYPE_2D ||
+ create_info->format != VK_FORMAT_R8G8B8A8_UNORM ||
+@@ -534,9 +537,9 @@ VkResult CreateImage(VkDevice device,
+
+ if (!allocator)
+ allocator = &device->allocator;
+- Image* image = static_cast<Image*>(
+- allocator->pfnAlloc(allocator->pUserData, sizeof(Image), alignof(Image),
+- VK_SYSTEM_ALLOC_SCOPE_OBJECT));
++ Image* image = static_cast<Image*>(allocator->pfnAllocation(
++ allocator->pUserData, sizeof(Image), alignof(Image),
++ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
+ if (!image)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ image->size = size;
+@@ -555,7 +558,7 @@ void GetImageMemoryRequirements(VkDevice,
+
+ void DestroyImage(VkDevice device,
+ VkImage image_handle,
+- const VkAllocCallbacks* allocator) {
++ const VkAllocationCallbacks* allocator) {
+ if (!allocator)
+ allocator = &device->allocator;
+ Image* image = GetImageFromHandle(image_handle);
+@@ -567,7 +570,7 @@ void DestroyImage(VkDevice device,
+
+ VkResult CreateBufferView(VkDevice device,
+ const VkBufferViewCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkBufferView* view) {
+ *view = AllocHandle(device, HandleType::kBufferView);
+ return VK_SUCCESS;
+@@ -575,15 +578,15 @@ VkResult CreateBufferView(VkDevice device,
+
+ VkResult CreateDescriptorPool(VkDevice device,
+ const VkDescriptorPoolCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkDescriptorPool* pool) {
+ *pool = AllocHandle(device, HandleType::kDescriptorPool);
+ return VK_SUCCESS;
+ }
+
+-VkResult AllocDescriptorSets(VkDevice device,
+- const VkDescriptorSetAllocInfo* alloc_info,
+- VkDescriptorSet* descriptor_sets) {
++VkResult AllocateDescriptorSets(VkDevice device,
++ const VkDescriptorSetAllocateInfo* alloc_info,
++ VkDescriptorSet* descriptor_sets) {
+ for (uint32_t i = 0; i < alloc_info->setLayoutCount; i++)
+ descriptor_sets[i] = AllocHandle(device, HandleType::kDescriptorSet);
+ return VK_SUCCESS;
+@@ -591,7 +594,7 @@ VkResult AllocDescriptorSets(VkDevice device,
+
+ VkResult CreateDescriptorSetLayout(VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkDescriptorSetLayout* layout) {
+ *layout = AllocHandle(device, HandleType::kDescriptorSetLayout);
+ return VK_SUCCESS;
+@@ -599,7 +602,7 @@ VkResult CreateDescriptorSetLayout(VkDevice device,
+
+ VkResult CreateEvent(VkDevice device,
+ const VkEventCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkEvent* event) {
+ *event = AllocHandle(device, HandleType::kEvent);
+ return VK_SUCCESS;
+@@ -607,7 +610,7 @@ VkResult CreateEvent(VkDevice device,
+
+ VkResult CreateFence(VkDevice device,
+ const VkFenceCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkFence* fence) {
+ *fence = AllocHandle(device, HandleType::kFence);
+ return VK_SUCCESS;
+@@ -615,7 +618,7 @@ VkResult CreateFence(VkDevice device,
+
+ VkResult CreateFramebuffer(VkDevice device,
+ const VkFramebufferCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkFramebuffer* framebuffer) {
+ *framebuffer = AllocHandle(device, HandleType::kFramebuffer);
+ return VK_SUCCESS;
+@@ -623,7 +626,7 @@ VkResult CreateFramebuffer(VkDevice device,
+
+ VkResult CreateImageView(VkDevice device,
+ const VkImageViewCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkImageView* view) {
+ *view = AllocHandle(device, HandleType::kImageView);
+ return VK_SUCCESS;
+@@ -633,7 +636,7 @@ VkResult CreateGraphicsPipelines(VkDevice device,
+ VkPipelineCache,
+ uint32_t count,
+ const VkGraphicsPipelineCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkPipeline* pipelines) {
+ for (uint32_t i = 0; i < count; i++)
+ pipelines[i] = AllocHandle(device, HandleType::kPipeline);
+@@ -644,7 +647,7 @@ VkResult CreateComputePipelines(VkDevice device,
+ VkPipelineCache,
+ uint32_t count,
+ const VkComputePipelineCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkPipeline* pipelines) {
+ for (uint32_t i = 0; i < count; i++)
+ pipelines[i] = AllocHandle(device, HandleType::kPipeline);
+@@ -653,7 +656,7 @@ VkResult CreateComputePipelines(VkDevice device,
+
+ VkResult CreatePipelineCache(VkDevice device,
+ const VkPipelineCacheCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkPipelineCache* cache) {
+ *cache = AllocHandle(device, HandleType::kPipelineCache);
+ return VK_SUCCESS;
+@@ -661,7 +664,7 @@ VkResult CreatePipelineCache(VkDevice device,
+
+ VkResult CreatePipelineLayout(VkDevice device,
+ const VkPipelineLayoutCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkPipelineLayout* layout) {
+ *layout = AllocHandle(device, HandleType::kPipelineLayout);
+ return VK_SUCCESS;
+@@ -669,7 +672,7 @@ VkResult CreatePipelineLayout(VkDevice device,
+
+ VkResult CreateQueryPool(VkDevice device,
+ const VkQueryPoolCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkQueryPool* pool) {
+ *pool = AllocHandle(device, HandleType::kQueryPool);
+ return VK_SUCCESS;
+@@ -677,7 +680,7 @@ VkResult CreateQueryPool(VkDevice device,
+
+ VkResult CreateRenderPass(VkDevice device,
+ const VkRenderPassCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkRenderPass* renderpass) {
+ *renderpass = AllocHandle(device, HandleType::kRenderPass);
+ return VK_SUCCESS;
+@@ -685,7 +688,7 @@ VkResult CreateRenderPass(VkDevice device,
+
+ VkResult CreateSampler(VkDevice device,
+ const VkSamplerCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkSampler* sampler) {
+ *sampler = AllocHandle(device, HandleType::kSampler);
+ return VK_SUCCESS;
+@@ -693,7 +696,7 @@ VkResult CreateSampler(VkDevice device,
+
+ VkResult CreateSemaphore(VkDevice device,
+ const VkSemaphoreCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkSemaphore* semaphore) {
+ *semaphore = AllocHandle(device, HandleType::kSemaphore);
+ return VK_SUCCESS;
+@@ -701,7 +704,7 @@ VkResult CreateSemaphore(VkDevice device,
+
+ VkResult CreateShader(VkDevice device,
+ const VkShaderCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkShader* shader) {
+ *shader = AllocHandle(device, HandleType::kShader);
+ return VK_SUCCESS;
+@@ -709,7 +712,7 @@ VkResult CreateShader(VkDevice device,
+
+ VkResult CreateShaderModule(VkDevice device,
+ const VkShaderModuleCreateInfo*,
+- const VkAllocCallbacks* /*allocator*/,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkShaderModule* module) {
+ *module = AllocHandle(device, HandleType::kShaderModule);
+ return VK_SUCCESS;
+@@ -820,7 +823,7 @@ VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSpar
+ return VK_SUCCESS;
+ }
+
+-void DestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* allocator) {
++void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator) {
+ }
+
+ VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
+@@ -836,10 +839,10 @@ VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFen
+ return VK_SUCCESS;
+ }
+
+-void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* allocator) {
++void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* allocator) {
+ }
+
+-void DestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* allocator) {
++void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* allocator) {
+ }
+
+ VkResult GetEventStatus(VkDevice device, VkEvent event) {
+@@ -857,7 +860,7 @@ VkResult ResetEvent(VkDevice device, VkEvent event) {
+ return VK_SUCCESS;
+ }
+
+-void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* allocator) {
++void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* allocator) {
+ }
+
+ VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
+@@ -865,23 +868,23 @@ VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t st
+ return VK_SUCCESS;
+ }
+
+-void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* allocator) {
++void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* allocator) {
+ }
+
+ void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ }
+
+-void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* allocator) {
++void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator) {
+ }
+
+-void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* allocator) {
++void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator) {
+ }
+
+-void DestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* allocator) {
++void DestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* allocator) {
+ }
+
+-void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* allocator) {
++void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator) {
+ }
+
+ VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
+@@ -894,19 +897,19 @@ VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_
+ return VK_SUCCESS;
+ }
+
+-void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* allocator) {
++void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* allocator) {
+ }
+
+-void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* allocator) {
++void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* allocator) {
+ }
+
+-void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* allocator) {
++void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* allocator) {
+ }
+
+-void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* allocator) {
++void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* allocator) {
+ }
+
+-void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* allocator) {
++void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* allocator) {
+ }
+
+ VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
+@@ -923,164 +926,164 @@ VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, ui
+ return VK_SUCCESS;
+ }
+
+-void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* allocator) {
++void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* allocator) {
+ }
+
+-void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* allocator) {
++void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* allocator) {
+ }
+
+ void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ }
+
+-VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) {
++VkResult ResetCommandPool(VkDevice device, VkCommandPool cmdPool, VkCommandPoolResetFlags flags) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ return VK_SUCCESS;
+ }
+
+-VkResult BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) {
++VkResult BeginCommandBuffer(VkCommandBuffer cmdBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
+ return VK_SUCCESS;
+ }
+
+-VkResult EndCommandBuffer(VkCmdBuffer cmdBuffer) {
++VkResult EndCommandBuffer(VkCommandBuffer cmdBuffer) {
+ return VK_SUCCESS;
+ }
+
+-VkResult ResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) {
++VkResult ResetCommandBuffer(VkCommandBuffer cmdBuffer, VkCommandBufferResetFlags flags) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ return VK_SUCCESS;
+ }
+
+-void CmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
++void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+ }
+
+-void CmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
++void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
+ }
+
+-void CmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
++void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
+ }
+
+-void CmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth) {
++void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth) {
+ }
+
+-void CmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) {
++void CmdSetDepthBias(VkCommandBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) {
+ }
+
+-void CmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConst[4]) {
++void CmdSetBlendConstants(VkCommandBuffer cmdBuffer, const float blendConst[4]) {
+ }
+
+-void CmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) {
++void CmdSetDepthBounds(VkCommandBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) {
+ }
+
+-void CmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
++void CmdSetStencilCompareMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
+ }
+
+-void CmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
++void CmdSetStencilWriteMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
+ }
+
+-void CmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
++void CmdSetStencilReference(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
+ }
+
+-void CmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
++void CmdBindDescriptorSets(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+ }
+
+-void CmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
++void CmdBindIndexBuffer(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
+ }
+
+-void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
++void CmdBindVertexBuffers(VkCommandBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
+ }
+
+-void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
++void CmdDraw(VkCommandBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+ }
+
+-void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
++void CmdDrawIndexed(VkCommandBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+ }
+
+-void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
++void CmdDrawIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
+ }
+
+-void CmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
++void CmdDrawIndexedIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
+ }
+
+-void CmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
++void CmdDispatch(VkCommandBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
+ }
+
+-void CmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
++void CmdDispatchIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
+ }
+
+-void CmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
++void CmdCopyBuffer(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
+ }
+
+-void CmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
++void CmdCopyImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
+ }
+
+-void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
++void CmdBlitImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+ }
+
+-void CmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
++void CmdCopyBufferToImage(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ }
+
+-void CmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
++void CmdCopyImageToBuffer(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ }
+
+-void CmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) {
++void CmdUpdateBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) {
+ }
+
+-void CmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
++void CmdFillBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
+ }
+
+-void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
++void CmdClearColorImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ }
+
+-void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
++void CmdClearDepthStencilImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ }
+
+-void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
++void CmdClearAttachments(VkCommandBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+ }
+
+-void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
++void CmdResolveImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+ }
+
+-void CmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
++void CmdSetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+ }
+
+-void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
++void CmdResetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+ }
+
+-void CmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
++void CmdWaitEvents(VkCommandBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+ }
+
+-void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
++void CmdPipelineBarrier(VkCommandBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+ }
+
+-void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
++void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
+ }
+
+-void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
++void CmdEndQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
+ }
+
+-void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
++void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
+ }
+
+-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
++void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
+ }
+
+-void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
++void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
+ }
+
+-void CmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
++void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
+ }
+
+-void CmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
++void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
+ }
+
+-void CmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents) {
++void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkRenderPassContents contents) {
+ }
+
+-void CmdEndRenderPass(VkCmdBuffer cmdBuffer) {
++void CmdEndRenderPass(VkCommandBuffer cmdBuffer) {
+ }
+
+-void CmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) {
++void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers) {
+ }
+
+ #pragma clang diagnostic pop
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 5f3e53e..939a559 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -27,7 +27,7 @@ PFN_vkVoidFunction LookupInstanceProcAddr(const char* name);
+ PFN_vkVoidFunction LookupDeviceProcAddr(const char* name);
+
+ // clang-format off
+-void DestroyInstance(VkInstance instance, const VkAllocCallbacks* allocator);
++void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* allocator);
+ VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+ void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+ void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+@@ -37,8 +37,8 @@ void GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uin
+ void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
+ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
+-VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDevice* pDevice);
+-void DestroyDevice(VkDevice device, const VkAllocCallbacks* allocator);
++VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDevice* pDevice);
++void DestroyDevice(VkDevice device, const VkAllocationCallbacks* allocator);
+ VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+ VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+ VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);
+@@ -47,8 +47,8 @@ void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIn
+ VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
+ VkResult QueueWaitIdle(VkQueue queue);
+ VkResult DeviceWaitIdle(VkDevice device);
+-VkResult AllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* allocator, VkDeviceMemory* pMem);
+-void FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* allocator);
++VkResult AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocInfo, const VkAllocationCallbacks* allocator, VkDeviceMemory* pMem);
++void FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* allocator);
+ VkResult MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
+ void UnmapMemory(VkDevice device, VkDeviceMemory mem);
+ VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+@@ -61,110 +61,110 @@ void GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirem
+ void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+ void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+ VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
+-VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkFence* pFence);
+-void DestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* allocator);
++VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkFence* pFence);
++void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator);
+ VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
+ VkResult GetFenceStatus(VkDevice device, VkFence fence);
+ VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
+-VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkSemaphore* pSemaphore);
+-void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* allocator);
+-VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkEvent* pEvent);
+-void DestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* allocator);
++VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkSemaphore* pSemaphore);
++void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* allocator);
++VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkEvent* pEvent);
++void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* allocator);
+ VkResult GetEventStatus(VkDevice device, VkEvent event);
+ VkResult SetEvent(VkDevice device, VkEvent event);
+ VkResult ResetEvent(VkDevice device, VkEvent event);
+-VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkQueryPool* pQueryPool);
+-void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* allocator);
++VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkQueryPool* pQueryPool);
++void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* allocator);
+ VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+-VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkBuffer* pBuffer);
+-void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* allocator);
+-VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkBufferView* pView);
+-void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* allocator);
+-VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkImage* pImage);
+-void DestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* allocator);
++VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkBuffer* pBuffer);
++void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* allocator);
++VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkBufferView* pView);
++void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* allocator);
++VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkImage* pImage);
++void DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* allocator);
+ void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+-VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkImageView* pView);
+-void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* allocator);
+-VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkShaderModule* pShaderModule);
+-void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* allocator);
+-VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkShader* pShader);
+-void DestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* allocator);
+-VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkPipelineCache* pPipelineCache);
+-void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* allocator);
++VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkImageView* pView);
++void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator);
++VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkShaderModule* pShaderModule);
++void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator);
++VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkShader* pShader);
++void DestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* allocator);
++VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkPipelineCache* pPipelineCache);
++void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator);
+ VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+ VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+-VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* allocator, VkPipeline* pPipelines);
+-VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* allocator, VkPipeline* pPipelines);
+-void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* allocator);
+-VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkPipelineLayout* pPipelineLayout);
+-void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* allocator);
+-VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkSampler* pSampler);
+-void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* allocator);
+-VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDescriptorSetLayout* pSetLayout);
+-void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* allocator);
+-VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDescriptorPool* pDescriptorPool);
+-void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* allocator);
++VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* allocator, VkPipeline* pPipelines);
++VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* allocator, VkPipeline* pPipelines);
++void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* allocator);
++VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkPipelineLayout* pPipelineLayout);
++void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* allocator);
++VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkSampler* pSampler);
++void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* allocator);
++VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDescriptorSetLayout* pSetLayout);
++void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* allocator);
++VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDescriptorPool* pDescriptorPool);
++void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* allocator);
+ VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+-VkResult AllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
++VkResult AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
+ VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
+ void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+-VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkFramebuffer* pFramebuffer);
+-void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* allocator);
+-VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkRenderPass* pRenderPass);
+-void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* allocator);
++VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkFramebuffer* pFramebuffer);
++void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* allocator);
++VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkRenderPass* pRenderPass);
++void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* allocator);
+ void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+-VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkCmdPool* pCmdPool);
+-void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* allocator);
+-VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
+-VkResult AllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
+-void FreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers);
+-VkResult BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
+-VkResult EndCommandBuffer(VkCmdBuffer cmdBuffer);
+-VkResult ResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
+-void CmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+-void CmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
+-void CmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
+-void CmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth);
+-void CmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias);
+-void CmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConst[4]);
+-void CmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
+-void CmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
+-void CmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
+-void CmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
+-void CmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+-void CmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+-void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+-void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+-void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+-void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
+-void CmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
+-void CmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
+-void CmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
+-void CmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+-void CmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+-void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+-void CmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+-void CmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+-void CmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
+-void CmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
+-void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+-void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+-void CmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+-void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+-void CmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+-void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+-void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+-void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+-void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
+-void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
+-void CmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
+-void CmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+-void CmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents);
+-void CmdEndRenderPass(VkCmdBuffer cmdBuffer);
+-void CmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers);
++VkResult CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkCommandPool* pCmdPool);
++void DestroyCommandPool(VkDevice device, VkCommandPool cmdPool, const VkAllocationCallbacks* allocator);
++VkResult ResetCommandPool(VkDevice device, VkCommandPool cmdPool, VkCommandPoolResetFlags flags);
++VkResult AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocInfo, VkCommandBuffer* pCmdBuffers);
++void FreeCommandBuffers(VkDevice device, VkCommandPool cmdPool, uint32_t count, const VkCommandBuffer* pCommandBuffers);
++VkResult BeginCommandBuffer(VkCommandBuffer cmdBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
++VkResult EndCommandBuffer(VkCommandBuffer cmdBuffer);
++VkResult ResetCommandBuffer(VkCommandBuffer cmdBuffer, VkCommandBufferResetFlags flags);
++void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
++void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
++void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
++void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth);
++void CmdSetDepthBias(VkCommandBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias);
++void CmdSetBlendConstants(VkCommandBuffer cmdBuffer, const float blendConst[4]);
++void CmdSetDepthBounds(VkCommandBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
++void CmdSetStencilCompareMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
++void CmdSetStencilWriteMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
++void CmdSetStencilReference(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
++void CmdBindDescriptorSets(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
++void CmdBindIndexBuffer(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
++void CmdBindVertexBuffers(VkCommandBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
++void CmdDraw(VkCommandBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
++void CmdDrawIndexed(VkCommandBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
++void CmdDrawIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
++void CmdDrawIndexedIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
++void CmdDispatch(VkCommandBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
++void CmdDispatchIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
++void CmdCopyBuffer(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
++void CmdCopyImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
++void CmdBlitImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
++void CmdCopyBufferToImage(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
++void CmdCopyImageToBuffer(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
++void CmdUpdateBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
++void CmdFillBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
++void CmdClearColorImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
++void CmdClearDepthStencilImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
++void CmdClearAttachments(VkCommandBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
++void CmdResolveImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
++void CmdSetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
++void CmdResetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
++void CmdWaitEvents(VkCommandBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
++void CmdPipelineBarrier(VkCommandBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
++void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
++void CmdEndQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
++void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
++void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
++void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
++void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
++void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
++void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkRenderPassContents contents);
++void CmdEndRenderPass(VkCommandBuffer cmdBuffer);
++void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers);
+
+ VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
+ VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore);
+diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
+index f836a70..9b1b042 100644
+--- a/vulkan/nulldrv/null_driver_gen.cpp
++++ b/vulkan/nulldrv/null_driver_gen.cpp
+@@ -67,9 +67,9 @@ const NameProcEntry kInstanceProcTbl[] = {
+
+ const NameProcEntry kDeviceProcTbl[] = {
+ // clang-format off
+- {"vkAllocCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocCommandBuffers>(AllocCommandBuffers))},
+- {"vkAllocDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocDescriptorSets>(AllocDescriptorSets))},
+- {"vkAllocMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocMemory>(AllocMemory))},
++ {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateCommandBuffers>(AllocateCommandBuffers))},
++ {"vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateDescriptorSets>(AllocateDescriptorSets))},
++ {"vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateMemory>(AllocateMemory))},
+ {"vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkBeginCommandBuffer>(BeginCommandBuffer))},
+ {"vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkBindBufferMemory>(BindBufferMemory))},
+ {"vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkBindImageMemory>(BindImageMemory))},
+diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
+index eaec272..838d0e2 100644
+--- a/vulkan/tools/vkinfo.cpp
++++ b/vulkan/tools/vkinfo.cpp
+@@ -157,7 +157,7 @@ int main(int /*argc*/, char const* /*argv*/ []) {
+ const VkInstanceCreateInfo create_info = {
+ .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+ .pNext = nullptr,
+- .pAppInfo = nullptr,
++ .pApplicationInfo = nullptr,
+ .enabledLayerNameCount = 0,
+ .ppEnabledLayerNames = nullptr,
+ .enabledExtensionNameCount = 0,
+--
+2.4.0
+
--- /dev/null
+From 28e4f6d9fdb6ac3fec47d7cb12a7b90caa737394 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Sun, 29 Nov 2015 23:50:38 -0800
+Subject: [PATCH 19/30] vulkan: Update from version 0.196.0 to 0.197.0
+
+Change-Id: I1c7aecd276cb8d831b8d7bf7eef58b5c6ad8b82c
+---
+ vulkan/api/vulkan.api | 24 ++++++++++++------------
+ vulkan/include/vulkan/vulkan.h | 22 ++++++++++------------
+ vulkan/nulldrv/null_driver.cpp | 7 +++++--
+ vulkan/tools/vkinfo.cpp | 16 ++++++++--------
+ 4 files changed, 35 insertions(+), 34 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 7313904..9575407 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 196
++define VERSION_MINOR 197
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -723,18 +723,17 @@ bitfield VkQueueFlagBits {
+ /// Memory properties passed into vkAllocMemory().
+ type VkFlags VkMemoryPropertyFlags
+ bitfield VkMemoryPropertyFlagBits {
+- VK_MEMORY_PROPERTY_DEVICE_ONLY = 0x00000000, /// If otherwise stated, then allocate memory on device
+- VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001, /// Memory should be mappable by host
+- VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, /// Memory may not have i/o coherency so vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges must be used flush/invalidate host cache
+- /// vkInvalidateMappedMemoryRanges must be used flush/invalidate host cache
+- VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004, /// Memory should not be cached by the host
+- VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000008, /// Memory may be allocated by the driver when it is required
++ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
++ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
++ VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
++ VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
++ VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
+ }
+
+ /// Memory heap flags
+ type VkFlags VkMemoryHeapFlags
+ bitfield VkMemoryHeapFlagBits {
+- VK_MEMORY_HEAP_HOST_LOCAL_BIT = 0x00000001, /// If set, heap represents host memory
++ VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
+ }
+
+ /// Memory output flags passed to resource transition commands
+@@ -953,9 +952,8 @@ bitfield VkImageAspectFlagBits {
+
+ /// Sparse memory bind flags
+ type VkFlags VkSparseMemoryBindFlags
+-bitfield VkSparseMemoryBindFlagBits {
+- VK_SPARSE_MEMORY_BIND_REPLICATE_BLOCK_BIT = 0x00000001,
+-}
++//bitfield VkSparseMemoryBindFlagBits {
++//}
+
+ /// Sparse image memory requirements flags
+ type VkFlags VkSparseImageFormatFlags
+@@ -2076,6 +2074,8 @@ class VkPhysicalDeviceFeatures {
+ VkBool32 shaderImageGatherExtended /// texture gather with run-time values and independent offsets
+ VkBool32 shaderStorageImageExtendedFormats /// the extended set of formats can be used for storage images
+ VkBool32 shaderStorageImageMultisample /// multisample images can be used for storage images
++ VkBool32 shaderStorageImageReadWithoutFormat
++ VkBool32 shaderStorageImageWriteWithoutFormat
+ VkBool32 shaderUniformBufferArrayDynamicIndexing /// arrays of uniform buffers can be accessed with dynamically uniform indices
+ VkBool32 shaderSampledImageArrayDynamicIndexing /// arrays of sampled images can be accessed with dynamically uniform indices
+ VkBool32 shaderStorageBufferArrayDynamicIndexing /// arrays of storage buffers can be accessed with dynamically uniform indices
+@@ -2096,6 +2096,7 @@ class VkPhysicalDeviceFeatures {
+ VkBool32 sparseResidency8Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples
+ VkBool32 sparseResidency16Samples /// Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples
+ VkBool32 sparseResidencyAliased /// Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in)
++ VkBool32 variableMultisampleRate
+ }
+
+ class VkPhysicalDeviceLimits {
+@@ -2226,7 +2227,6 @@ class VkPhysicalDeviceSparseProperties {
+ VkBool32 residencyStandard2DMultisampleBlockShape /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format)
+ VkBool32 residencyStandard3DBlockShape /// Sparse resources support: GPU will access all 3D sparse resources using the standard block shapes (based on pixel format)
+ VkBool32 residencyAlignedMipSize /// Sparse resources support: Images with mip-level dimensions that are NOT a multiple of the block size will be placed in the mip tail
+- VkBool32 residencyNonResident /// Sparse resources support: GPU can safely access non-resident regions of a resource, read values from read-write resources are undefined
+ VkBool32 residencyNonResidentStrict /// Sparse resources support: GPU can safely access non-resident regions of a resource, all reads return as if data is 0, writes are discarded
+ }
+
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 0130399..cbd15e6 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 196, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 197, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -810,16 +810,16 @@ typedef enum {
+ typedef VkFlags VkQueueFlags;
+
+ typedef enum {
+- VK_MEMORY_PROPERTY_DEVICE_ONLY = 0,
+- VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001,
+- VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002,
+- VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004,
+- VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000008,
++ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
++ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
++ VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
++ VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
++ VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
+ } VkMemoryPropertyFlagBits;
+ typedef VkFlags VkMemoryPropertyFlags;
+
+ typedef enum {
+- VK_MEMORY_HEAP_HOST_LOCAL_BIT = 0x00000001,
++ VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
+ } VkMemoryHeapFlagBits;
+ typedef VkFlags VkMemoryHeapFlags;
+ typedef VkFlags VkDeviceCreateFlags;
+@@ -839,10 +839,6 @@ typedef enum {
+ VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
+ } VkSparseImageFormatFlagBits;
+ typedef VkFlags VkSparseImageFormatFlags;
+-
+-typedef enum {
+- VK_SPARSE_MEMORY_BIND_REPLICATE_BLOCK_BIT = 0x00000001,
+-} VkSparseMemoryBindFlagBits;
+ typedef VkFlags VkSparseMemoryBindFlags;
+
+ typedef enum {
+@@ -1141,6 +1137,8 @@ typedef struct {
+ VkBool32 shaderImageGatherExtended;
+ VkBool32 shaderStorageImageExtendedFormats;
+ VkBool32 shaderStorageImageMultisample;
++ VkBool32 shaderStorageImageReadWithoutFormat;
++ VkBool32 shaderStorageImageWriteWithoutFormat;
+ VkBool32 shaderUniformBufferArrayDynamicIndexing;
+ VkBool32 shaderSampledImageArrayDynamicIndexing;
+ VkBool32 shaderStorageBufferArrayDynamicIndexing;
+@@ -1161,6 +1159,7 @@ typedef struct {
+ VkBool32 sparseResidency8Samples;
+ VkBool32 sparseResidency16Samples;
+ VkBool32 sparseResidencyAliased;
++ VkBool32 variableMultisampleRate;
+ } VkPhysicalDeviceFeatures;
+
+ typedef struct {
+@@ -1290,7 +1289,6 @@ typedef struct {
+ VkBool32 residencyStandard2DMultisampleBlockShape;
+ VkBool32 residencyStandard3DBlockShape;
+ VkBool32 residencyAlignedMipSize;
+- VkBool32 residencyNonResident;
+ VkBool32 residencyNonResidentStrict;
+ } VkPhysicalDeviceSparseProperties;
+
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index d134c0e..b2b905f 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -292,11 +292,14 @@ void GetPhysicalDeviceMemoryProperties(
+ VkPhysicalDeviceMemoryProperties* properties) {
+ properties->memoryTypeCount = 1;
+ properties->memoryTypes[0].propertyFlags =
+- VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
++ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
++ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
++ VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
++ VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+ properties->memoryTypes[0].heapIndex = 0;
+ properties->memoryHeapCount = 1;
+ properties->memoryHeaps[0].size = kMaxDeviceMemory;
+- properties->memoryHeaps[0].flags = VK_MEMORY_HEAP_HOST_LOCAL_BIT;
++ properties->memoryHeaps[0].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
+ }
+
+ // -----------------------------------------------------------------------------
+diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
+index 838d0e2..1920d6b 100644
+--- a/vulkan/tools/vkinfo.cpp
++++ b/vulkan/tools/vkinfo.cpp
+@@ -98,8 +98,8 @@ void DumpPhysicalDevice(uint32_t idx, VkPhysicalDevice pdev) {
+ vkGetPhysicalDeviceMemoryProperties(pdev, &mem_props);
+ for (uint32_t heap = 0; heap < mem_props.memoryHeapCount; heap++) {
+ if ((mem_props.memoryHeaps[heap].flags &
+- VK_MEMORY_HEAP_HOST_LOCAL_BIT) != 0)
+- strbuf << "HOST_LOCAL";
++ VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
++ strbuf << "DEVICE_LOCAL";
+ printf(" Heap %u: 0x%" PRIx64 " %s\n", heap,
+ mem_props.memoryHeaps[heap].size, strbuf.str().c_str());
+ strbuf.str(std::string());
+@@ -109,14 +109,14 @@ void DumpPhysicalDevice(uint32_t idx, VkPhysicalDevice pdev) {
+ continue;
+ VkMemoryPropertyFlags flags =
+ mem_props.memoryTypes[type].propertyFlags;
+- if (flags == VK_MEMORY_PROPERTY_DEVICE_ONLY)
+- strbuf << "DEVICE_ONLY";
++ if ((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
++ strbuf << "DEVICE_LOCAL";
+ if ((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
+ strbuf << "HOST_VISIBLE";
+- if ((flags & VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT) != 0)
+- strbuf << " NON_COHERENT";
+- if ((flags & VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT) != 0)
+- strbuf << " UNCACHED";
++ if ((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
++ strbuf << " COHERENT";
++ if ((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
++ strbuf << " CACHED";
+ if ((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
+ strbuf << " LAZILY_ALLOCATED";
+ printf(" Type %u: %s\n", type, strbuf.str().c_str());
+--
+2.4.0
+
--- /dev/null
+From 16dcb975a508d8c23006200f42e00c23d0376511 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 30 Nov 2015 00:07:16 -0800
+Subject: [PATCH 20/30] vulkan: Update from version 0.197.0 to 0.198.0
+
+Change-Id: I182b21c68374e8eae962b2ae391bb283f07d5517
+---
+ vulkan/api/vulkan.api | 243 +++++++++++++++---------------
+ vulkan/include/vulkan/vk_platform.h | 7 +-
+ vulkan/include/vulkan/vulkan.h | 293 ++++++++++++++++++------------------
+ vulkan/libvulkan/entry.cpp | 28 ++--
+ vulkan/nulldrv/null_driver.cpp | 12 +-
+ vulkan/nulldrv/null_driver.h | 4 +-
+ vulkan/tools/vkinfo.cpp | 8 +-
+ 7 files changed, 297 insertions(+), 298 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 9575407..ab887fa 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,16 +27,16 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 197
++define VERSION_MINOR 198
+ define VERSION_PATCH 0
+
+ // API limits
+-define VK_MAX_PHYSICAL_DEVICE_NAME 256
+-define VK_UUID_LENGTH 16
+-define VK_MAX_EXTENSION_NAME 256
+-define VK_MAX_DESCRIPTION 256
+-define VK_MAX_MEMORY_TYPES 32
+-define VK_MAX_MEMORY_HEAPS 16 /// The maximum number of unique memory heaps, each of which supporting 1 or more memory types.
++define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256
++define VK_UUID_SIZE 16
++define VK_MAX_EXTENSION_NAME_SIZE 256
++define VK_MAX_DESCRIPTION_SIZE 256
++define VK_MAX_MEMORY_TYPES 32
++define VK_MAX_MEMORY_HEAPS 16 /// The maximum number of unique memory heaps, each of which supporting 1 or more memory types.
+
+ // API keywords
+ define VK_TRUE 1
+@@ -189,14 +189,14 @@ enum VkCommandBufferLevel {
+ VK_COMMAND_BUFFER_LEVEL_SECONDARY = 0x00000001,
+ }
+
+-enum VkChannelSwizzle {
+- VK_CHANNEL_SWIZZLE_IDENTITY = 0x00000000,
+- VK_CHANNEL_SWIZZLE_ZERO = 0x00000001,
+- VK_CHANNEL_SWIZZLE_ONE = 0x00000002,
+- VK_CHANNEL_SWIZZLE_R = 0x00000003,
+- VK_CHANNEL_SWIZZLE_G = 0x00000004,
+- VK_CHANNEL_SWIZZLE_B = 0x00000005,
+- VK_CHANNEL_SWIZZLE_A = 0x00000006,
++enum VkComponentSwizzle {
++ VK_COMPONENT_SWIZZLE_IDENTITY = 0x00000000,
++ VK_COMPONENT_SWIZZLE_ZERO = 0x00000001,
++ VK_COMPONENT_SWIZZLE_ONE = 0x00000002,
++ VK_COMPONENT_SWIZZLE_R = 0x00000003,
++ VK_COMPONENT_SWIZZLE_G = 0x00000004,
++ VK_COMPONENT_SWIZZLE_B = 0x00000005,
++ VK_COMPONENT_SWIZZLE_A = 0x00000006,
+ }
+
+ enum VkDescriptorType {
+@@ -287,10 +287,10 @@ enum VkCompareOp {
+ VK_COMPARE_OP_ALWAYS = 0x00000007,
+ }
+
+-enum VkFillMode {
+- VK_FILL_MODE_SOLID = 0x00000000,
+- VK_FILL_MODE_WIREFRAME = 0x00000001,
+- VK_FILL_MODE_POINTS = 0x00000002,
++enum VkPolygonMode {
++ VK_POLYGON_MODE_FILL = 0x00000000,
++ VK_POLYGON_MODE_LINE = 0x00000001,
++ VK_POLYGON_MODE_POINT = 0x00000002,
+ }
+
+ enum VkFrontFace {
+@@ -298,26 +298,26 @@ enum VkFrontFace {
+ VK_FRONT_FACE_CLOCKWISE = 0x00000001,
+ }
+
+-enum VkBlend {
+- VK_BLEND_ZERO = 0x00000000,
+- VK_BLEND_ONE = 0x00000001,
+- VK_BLEND_SRC_COLOR = 0x00000002,
+- VK_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003,
+- VK_BLEND_DST_COLOR = 0x00000004,
+- VK_BLEND_ONE_MINUS_DST_COLOR = 0x00000005,
+- VK_BLEND_SRC_ALPHA = 0x00000006,
+- VK_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007,
+- VK_BLEND_DST_ALPHA = 0x00000008,
+- VK_BLEND_ONE_MINUS_DST_ALPHA = 0x00000009,
+- VK_BLEND_CONSTANT_COLOR = 0x0000000a,
+- VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
+- VK_BLEND_CONSTANT_ALPHA = 0x0000000c,
+- VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d,
+- VK_BLEND_SRC_ALPHA_SATURATE = 0x0000000e,
+- VK_BLEND_SRC1_COLOR = 0x0000000f,
+- VK_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010,
+- VK_BLEND_SRC1_ALPHA = 0x00000011,
+- VK_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012,
++enum VkBlendFactor {
++ VK_BLEND_FACTOR_ZERO = 0x00000000,
++ VK_BLEND_FACTOR_ONE = 0x00000001,
++ VK_BLEND_FACTOR_SRC_COLOR = 0x00000002,
++ VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 0x00000003,
++ VK_BLEND_FACTOR_DST_COLOR = 0x00000004,
++ VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 0x00000005,
++ VK_BLEND_FACTOR_SRC_ALPHA = 0x00000006,
++ VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 0x00000007,
++ VK_BLEND_FACTOR_DST_ALPHA = 0x00000008,
++ VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 0x00000009,
++ VK_BLEND_FACTOR_CONSTANT_COLOR = 0x0000000a,
++ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
++ VK_BLEND_FACTOR_CONSTANT_ALPHA = 0x0000000c,
++ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d,
++ VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 0x0000000e,
++ VK_BLEND_FACTOR_SRC1_COLOR = 0x0000000f,
++ VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 0x00000010,
++ VK_BLEND_FACTOR_SRC1_ALPHA = 0x00000011,
++ VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 0x00000012,
+ }
+
+ enum VkBlendOp {
+@@ -378,9 +378,9 @@ enum VkPhysicalDeviceType {
+ VK_PHYSICAL_DEVICE_TYPE_CPU = 0x00000004,
+ }
+
+-enum VkVertexInputStepRate {
+- VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x00000000,
+- VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x00000001,
++enum VkVertexInputRate {
++ VK_VERTEX_INPUT_RATE_VERTEX = 0x00000000,
++ VK_VERTEX_INPUT_RATE_INSTANCE = 0x00000001,
+ }
+
+ /// Vulkan format definitions
+@@ -587,7 +587,7 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 21,
+ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 22,
+ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 23,
+- VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 24,
++ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 24,
+ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 25,
+ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 26,
+ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
+@@ -625,9 +625,9 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR = 0xc0001001,
+ }
+
+-enum VkRenderPassContents {
+- VK_RENDER_PASS_CONTENTS_INLINE = 0x00000000,
+- VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 0x00000001,
++enum VkSubpassContents {
++ VK_SUBPASS_CONTENTS_INLINE = 0x00000000,
++ VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 0x00000001,
+ }
+
+ @lastUnused(-8)
+@@ -716,7 +716,7 @@ type VkFlags VkQueueFlags
+ bitfield VkQueueFlagBits {
+ VK_QUEUE_GRAPHICS_BIT = 0x00000001, /// Queue supports graphics operations
+ VK_QUEUE_COMPUTE_BIT = 0x00000002, /// Queue supports compute operations
+- VK_QUEUE_DMA_BIT = 0x00000004, /// Queue supports DMA operations
++ VK_QUEUE_TRANSFER_BIT = 0x00000004, /// Queue supports transfer operations
+ VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, /// Queue supports sparse resource memory management operations
+ }
+
+@@ -844,13 +844,13 @@ bitfield VkPipelineCreateFlagBits {
+ VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
+ }
+
+-/// Channel flags
+-type VkFlags VkChannelFlags
+-bitfield VkChannelFlagBits {
+- VK_CHANNEL_R_BIT = 0x00000001,
+- VK_CHANNEL_G_BIT = 0x00000002,
+- VK_CHANNEL_B_BIT = 0x00000004,
+- VK_CHANNEL_A_BIT = 0x00000008,
++/// Color component flags
++type VkFlags VkColorComponentFlags
++bitfield VkColorComponentFlagBits {
++ VK_COLOR_COMPONENT_R_BIT = 0x00000001,
++ VK_COLOR_COMPONENT_G_BIT = 0x00000002,
++ VK_COLOR_COMPONENT_B_BIT = 0x00000004,
++ VK_COLOR_COMPONENT_A_BIT = 0x00000008,
+ }
+
+ /// Fence creation flags
+@@ -884,7 +884,7 @@ bitfield VkFormatFeatureFlagBits {
+ /// Query control flags
+ type VkFlags VkQueryControlFlags
+ bitfield VkQueryControlFlagBits {
+- VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, /// Allow conservative results to be collected by the query
++ VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
+ }
+
+ /// Query result flags
+@@ -1215,8 +1215,8 @@ class VkExtent3D {
+ }
+
+ class VkViewport {
+- f32 originX
+- f32 originY
++ f32 x
++ f32 y
+ f32 width
+ f32 height
+ f32 minDepth
+@@ -1234,35 +1234,35 @@ class VkClearRect {
+ u32 layerCount
+ }
+
+-class VkChannelMapping {
+- VkChannelSwizzle r
+- VkChannelSwizzle g
+- VkChannelSwizzle b
+- VkChannelSwizzle a
++class VkComponentMapping {
++ VkComponentSwizzle r
++ VkComponentSwizzle g
++ VkComponentSwizzle b
++ VkComponentSwizzle a
+ }
+
+ class VkPhysicalDeviceProperties {
+ u32 apiVersion
+ u32 driverVersion
+- u32 vendorId
+- u32 deviceId
++ u32 vendorID
++ u32 deviceID
+ VkPhysicalDeviceType deviceType
+- char[VK_MAX_PHYSICAL_DEVICE_NAME] deviceName
+- u8[VK_UUID_LENGTH] pipelineCacheUUID
++ char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] deviceName
++ u8[VK_UUID_SIZE] pipelineCacheUUID
+ VkPhysicalDeviceLimits limits
+ VkPhysicalDeviceSparseProperties sparseProperties
+ }
+
+ class VkExtensionProperties {
+- char[VK_MAX_EXTENSION_NAME] extensionName /// extension name
++ char[VK_MAX_EXTENSION_NAME_SIZE] extensionName /// extension name
+ u32 specVersion /// version of the extension specification implemented
+ }
+
+ class VkLayerProperties {
+- char[VK_MAX_EXTENSION_NAME] layerName /// layer name
++ char[VK_MAX_EXTENSION_NAME_SIZE] layerName /// layer name
+ u32 specVersion /// version of the layer specification implemented
+ u32 implementationVersion /// build or release version of the layer's library
+- char[VK_MAX_DESCRIPTION] description /// Free-form description of the layer
++ char[VK_MAX_DESCRIPTION_SIZE] description /// Free-form description of the layer
+ }
+
+ class VkSubmitInfo {
+@@ -1332,6 +1332,7 @@ class VkQueueFamilyProperties {
+ VkQueueFlags queueFlags /// Queue flags
+ u32 queueCount
+ u32 timestampValidBits
++ VkExtent3D minImageTransferGranularity
+ }
+
+ class VkPhysicalDeviceMemoryProperties {
+@@ -1362,7 +1363,7 @@ class VkSparseImageFormatProperties {
+
+ class VkSparseImageMemoryRequirements {
+ VkSparseImageFormatProperties formatProperties
+- u32 imageMipTailStartLOD
++ u32 imageMipTailStartLod
+ VkDeviceSize imageMipTailSize /// Specified in bytes, must be a multiple of image block size / alignment
+ VkDeviceSize imageMipTailOffset /// Specified in bytes, must be a multiple of image block size / alignment
+ VkDeviceSize imageMipTailStride /// Specified in bytes, must be a multiple of image block size / alignment
+@@ -1536,7 +1537,7 @@ class VkImageViewCreateInfo {
+ VkImage image
+ VkImageViewType viewType
+ VkFormat format
+- VkChannelMapping channels
++ VkComponentMapping components
+ VkImageSubresourceRange subresourceRange
+ }
+
+@@ -1596,26 +1597,26 @@ class VkBindSparseInfo {
+ const VkSemaphore* pSignalSemaphores
+ }
+
+-class VkImageSubresourceCopy {
+- VkImageAspectFlags aspect
++class VkImageSubresourceLayers {
++ VkImageAspectFlags aspectMask
+ u32 mipLevel
+ u32 baseArrayLayer
+ u32 layerCount
+ }
+
+ class VkImageCopy {
+- VkImageSubresourceCopy srcSubresource
++ VkImageSubresourceLayers srcSubresource
+ VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images
+- VkImageSubresourceCopy dstSubresource
++ VkImageSubresourceLayers dstSubresource
+ VkOffset3D dstOffset /// Specified in pixels for both compressed and uncompressed images
+ VkExtent3D extent /// Specified in pixels for both compressed and uncompressed images
+ }
+
+ class VkImageBlit {
+- VkImageSubresourceCopy srcSubresource
++ VkImageSubresourceLayers srcSubresource
+ VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images
+ VkExtent3D srcExtent /// Specified in pixels for both compressed and uncompressed images
+- VkImageSubresourceCopy dstSubresource
++ VkImageSubresourceLayers dstSubresource
+ VkOffset3D dstOffset /// Specified in pixels for both compressed and uncompressed images
+ VkExtent3D dstExtent /// Specified in pixels for both compressed and uncompressed images
+ }
+@@ -1624,15 +1625,15 @@ class VkBufferImageCopy {
+ VkDeviceSize bufferOffset /// Specified in bytes
+ u32 bufferRowLength /// Specified in texels
+ u32 bufferImageHeight
+- VkImageSubresourceCopy imageSubresource
++ VkImageSubresourceLayers imageSubresource
+ VkOffset3D imageOffset /// Specified in pixels for both compressed and uncompressed images
+ VkExtent3D imageExtent /// Specified in pixels for both compressed and uncompressed images
+ }
+
+ class VkImageResolve {
+- VkImageSubresourceCopy srcSubresource
++ VkImageSubresourceLayers srcSubresource
+ VkOffset3D srcOffset
+- VkImageSubresourceCopy dstSubresource
++ VkImageSubresourceLayers dstSubresource
+ VkOffset3D dstOffset
+ VkExtent3D extent
+ }
+@@ -1669,7 +1670,7 @@ class VkDescriptorSetLayoutCreateInfo {
+ const VkDescriptorSetLayoutBinding* pBindings /// Array of descriptor set layout bindings
+ }
+
+-class VkDescriptorTypeCount {
++class VkDescriptorPoolSize {
+ VkDescriptorType type
+ u32 descriptorCount
+ }
+@@ -1679,8 +1680,8 @@ class VkDescriptorPoolCreateInfo {
+ const void* pNext /// Pointer to next structure
+ VkDescriptorPoolCreateFlags flags
+ u32 maxSets
+- u32 typeCount
+- const VkDescriptorTypeCount* pTypeCounts
++ u32 poolSizeCount
++ const VkDescriptorPoolSize* pPoolSizes
+ }
+
+ class VkDescriptorSetAllocateInfo {
+@@ -1692,7 +1693,7 @@ class VkDescriptorSetAllocateInfo {
+ }
+
+ class VkSpecializationMapEntry {
+- u32 constantId /// The SpecConstant ID specified in the BIL
++ u32 constantID /// The SpecConstant ID specified in the BIL
+ u32 offset /// Offset of the value in the data block
+ platform.size_t size /// Size in bytes of the SpecConstant
+ }
+@@ -1725,7 +1726,7 @@ class VkComputePipelineCreateInfo {
+ class VkVertexInputBindingDescription {
+ u32 binding /// Vertex buffer binding id
+ u32 stride /// Distance between vertices in bytes (0 = no advancement)
+- VkVertexInputStepRate stepRate /// Rate at which binding is incremented
++ VkVertexInputRate inputRate /// Rate at which binding is incremented
+ }
+
+ class VkVertexInputAttributeDescription {
+@@ -1771,12 +1772,12 @@ class VkPipelineViewportStateCreateInfo {
+ }
+
+ class VkPipelineRasterizationStateCreateInfo {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+ VkPipelineRasterizationStateCreateFlags flags
+ VkBool32 depthClampEnable
+ VkBool32 rasterizerDiscardEnable
+- VkFillMode fillMode /// optional (GL45)
++ VkPolygonMode polygonMode /// optional (GL45)
+ VkCullModeFlags cullMode
+ VkFrontFace frontFace
+ VkBool32 depthBiasEnable
+@@ -1800,13 +1801,13 @@ class VkPipelineMultisampleStateCreateInfo {
+
+ class VkPipelineColorBlendAttachmentState {
+ VkBool32 blendEnable
+- VkBlend srcBlendColor
+- VkBlend dstBlendColor
+- VkBlendOp blendOpColor
+- VkBlend srcBlendAlpha
+- VkBlend dstBlendAlpha
+- VkBlendOp blendOpAlpha
+- VkChannelFlags channelWriteMask
++ VkBlendFactor srcColorBlendFactor
++ VkBlendFactor dstColorBlendFactor
++ VkBlendOp colorBlendOp
++ VkBlendFactor srcAlphaBlendFactor
++ VkBlendFactor dstAlphaBlendFactor
++ VkBlendOp alphaBlendOp
++ VkColorComponentFlags colorWriteMask
+ }
+
+ class VkPipelineColorBlendStateCreateInfo {
+@@ -1821,13 +1822,13 @@ class VkPipelineColorBlendStateCreateInfo {
+ }
+
+ class VkStencilOpState {
+- VkStencilOp stencilFailOp
+- VkStencilOp stencilPassOp
+- VkStencilOp stencilDepthFailOp
+- VkCompareOp stencilCompareOp
+- u32 stencilCompareMask
+- u32 stencilWriteMask
+- u32 stencilReference
++ VkStencilOp failOp
++ VkStencilOp passOp
++ VkStencilOp depthFailOp
++ VkCompareOp compareOp
++ u32 compareMask
++ u32 writeMask
++ u32 reference
+ }
+
+ class VkPipelineDepthStencilStateCreateInfo {
+@@ -2066,7 +2067,7 @@ class VkPhysicalDeviceFeatures {
+ VkBool32 textureCompressionETC2 /// ETC texture compression formats
+ VkBool32 textureCompressionASTC_LDR /// ASTC LDR texture compression formats
+ VkBool32 textureCompressionBC /// BC1-7 texture compressed formats
+- VkBool32 occlusionQueryNonConservative /// non-conservative (exact) occlusion queries
++ VkBool32 occlusionQueryPrecise
+ VkBool32 pipelineStatisticsQuery /// pipeline statistics query
+ VkBool32 vertexPipelineStoresAndAtomics
+ VkBool32 fragmentStoresAndAtomics
+@@ -2086,7 +2087,7 @@ class VkPhysicalDeviceFeatures {
+ VkBool32 shaderInt64 /// 64-bit integers in shaders
+ VkBool32 shaderInt16 /// 16-bit integers in shaders
+ VkBool32 shaderResourceResidency /// shader can use texture operations that return resource residency information (requires sparseNonResident support)
+- VkBool32 shaderResourceMinLOD /// shader can use texture operations that specify minimum resource LOD
++ VkBool32 shaderResourceMinLod /// shader can use texture operations that specify minimum resource LOD
+ VkBool32 sparseBinding /// Sparse resources support: Resource memory can be managed at opaque page level rather than object level
+ VkBool32 sparseResidencyBuffer /// Sparse resources support: GPU can access partially resident buffers
+ VkBool32 sparseResidencyImage2D /// Sparse resources support: GPU can access partially resident 2D (non-MSAA non-DepthStencil) images
+@@ -2218,8 +2219,8 @@ class VkPhysicalDeviceLimits {
+ f32 lineWidthGranularity /// granularity of supported line widths
+ VkBool32 strictLines
+
+- VkDeviceSize recommendedBufferCopyOffsetAlignment
+- VkDeviceSize recommendedBufferCopyRowPitchAlignment
++ VkDeviceSize optimalBufferCopyOffsetAlignment
++ VkDeviceSize optimalBufferCopyRowPitchAlignment
+ }
+
+ class VkPhysicalDeviceSparseProperties {
+@@ -2241,7 +2242,7 @@ class VkQueryPoolCreateInfo {
+ const void* pNext /// Pointer to next structure
+ VkQueryPoolCreateFlags flags
+ VkQueryType queryType
+- u32 slots
++ u32 entryCount
+ VkQueryPipelineStatisticFlags pipelineStatistics /// Optional
+ }
+
+@@ -4001,7 +4002,7 @@ cmd void vkCmdSetDepthBounds(
+ cmd void vkCmdSetStencilCompareMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+- u32 stencilCompareMask) {
++ u32 compareMask) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+@@ -4010,7 +4011,7 @@ cmd void vkCmdSetStencilCompareMask(
+ cmd void vkCmdSetStencilWriteMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+- u32 stencilWriteMask) {
++ u32 writeMask) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+@@ -4019,7 +4020,7 @@ cmd void vkCmdSetStencilWriteMask(
+ cmd void vkCmdSetStencilReference(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+- u32 stencilReference) {
++ u32 reference) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ }
+@@ -4197,7 +4198,7 @@ cmd void vkCmdCopyBuffer(
+ bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
+ bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
+
+- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4223,7 +4224,7 @@ cmd void vkCmdCopyImage(
+ bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
+ bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
+
+- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4275,7 +4276,7 @@ cmd void vkCmdCopyBufferToImage(
+ bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
+ bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
+
+- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4300,7 +4301,7 @@ cmd void vkCmdCopyImageToBuffer(
+ bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
+ bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
+
+- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4318,7 +4319,7 @@ cmd void vkCmdUpdateBuffer(
+
+ bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
+
+- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4332,7 +4333,7 @@ cmd void vkCmdFillBuffer(
+ dstBufferObject := GetBuffer(dstBuffer)
+ assert(commandBufferObject.device == dstBufferObject.device)
+
+- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
++ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
+ }
+
+ @threadSafety("app")
+@@ -4514,7 +4515,7 @@ cmd void vkCmdPipelineBarrier(
+ cmd void vkCmdBeginQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+- u32 slot,
++ u32 entry,
+ VkQueryControlFlags flags) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ queryPoolObject := GetQueryPool(queryPool)
+@@ -4525,7 +4526,7 @@ cmd void vkCmdBeginQuery(
+ cmd void vkCmdEndQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+- u32 slot) {
++ u32 entry) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ queryPoolObject := GetQueryPool(queryPool)
+ assert(commandBufferObject.device == queryPoolObject.device)
+@@ -4547,7 +4548,7 @@ cmd void vkCmdWriteTimestamp(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+- u32 slot) {
++ u32 entry) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ queryPoolObject := GetQueryPool(queryPool)
+ assert(commandBufferObject.device == queryPoolObject.device)
+@@ -4586,7 +4587,7 @@ cmd void vkCmdPushConstants(
+ cmd void vkCmdBeginRenderPass(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+- VkRenderPassContents contents) {
++ VkSubpassContents contents) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ renderPassObject := GetRenderPass(pRenderPassBegin.renderPass)
+ framebufferObject := GetFramebuffer(pRenderPassBegin.framebuffer)
+@@ -4598,7 +4599,7 @@ cmd void vkCmdBeginRenderPass(
+
+ cmd void vkCmdNextSubpass(
+ VkCommandBuffer commandBuffer,
+- VkRenderPassContents contents) {
++ VkSubpassContents contents) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ }
+
+@@ -4855,7 +4856,7 @@ cmd VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ u32 queueFamilyIndex,
+ platform.Display* dpy,
+- platform.VisualID visualId) {
++ platform.VisualID visualID) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+ return ?
+ }
+diff --git a/vulkan/include/vulkan/vk_platform.h b/vulkan/include/vulkan/vk_platform.h
+index 8d51524..4bc6a86 100644
+--- a/vulkan/include/vulkan/vk_platform.h
++++ b/vulkan/include/vulkan/vk_platform.h
+@@ -42,12 +42,9 @@ extern "C"
+ #if defined(_WIN32)
+ // On Windows, VKAPI should equate to the __stdcall convention
+ #define VKAPI __stdcall
+-#elif defined(__GNUC__)
+- // On other platforms using GCC, VKAPI stays undefined
+- #define VKAPI
+ #else
+- // Unsupported Platform!
+- #error "Unsupported OS Platform detected!"
++ // On other platforms, use the default calling convention
++ #define VKAPI
+ #endif
+
+ #include <stddef.h>
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index cbd15e6..60583c2 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 197, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 198, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -100,12 +100,12 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
+ #define VK_FALSE 0
+ #define VK_QUEUE_FAMILY_IGNORED (~0U)
+ #define VK_SUBPASS_EXTERNAL (~0U)
+-#define VK_MAX_PHYSICAL_DEVICE_NAME 256
+-#define VK_UUID_LENGTH 16
++#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256
++#define VK_UUID_SIZE 16
+ #define VK_MAX_MEMORY_TYPES 32
+ #define VK_MAX_MEMORY_HEAPS 16
+-#define VK_MAX_EXTENSION_NAME 256
+-#define VK_MAX_DESCRIPTION 256
++#define VK_MAX_EXTENSION_NAME_SIZE 256
++#define VK_MAX_DESCRIPTION_SIZE 256
+
+
+ typedef enum {
+@@ -155,7 +155,7 @@ typedef enum {
+ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 21,
+ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 22,
+ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 23,
+- VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 24,
++ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 24,
+ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 25,
+ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 26,
+ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
+@@ -468,27 +468,27 @@ typedef enum {
+ } VkImageViewType;
+
+ typedef enum {
+- VK_CHANNEL_SWIZZLE_IDENTITY = 0,
+- VK_CHANNEL_SWIZZLE_ZERO = 1,
+- VK_CHANNEL_SWIZZLE_ONE = 2,
+- VK_CHANNEL_SWIZZLE_R = 3,
+- VK_CHANNEL_SWIZZLE_G = 4,
+- VK_CHANNEL_SWIZZLE_B = 5,
+- VK_CHANNEL_SWIZZLE_A = 6,
+- VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_IDENTITY,
+- VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A,
+- VK_CHANNEL_SWIZZLE_RANGE_SIZE = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_IDENTITY + 1),
+- VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
+-} VkChannelSwizzle;
++ VK_COMPONENT_SWIZZLE_IDENTITY = 0,
++ VK_COMPONENT_SWIZZLE_ZERO = 1,
++ VK_COMPONENT_SWIZZLE_ONE = 2,
++ VK_COMPONENT_SWIZZLE_R = 3,
++ VK_COMPONENT_SWIZZLE_G = 4,
++ VK_COMPONENT_SWIZZLE_B = 5,
++ VK_COMPONENT_SWIZZLE_A = 6,
++ VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
++ VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
++ VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
++ VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
++} VkComponentSwizzle;
+
+ typedef enum {
+- VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0,
+- VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1,
+- VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX,
+- VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_INSTANCE,
+- VK_VERTEX_INPUT_STEP_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1),
+- VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF
+-} VkVertexInputStepRate;
++ VK_VERTEX_INPUT_RATE_VERTEX = 0,
++ VK_VERTEX_INPUT_RATE_INSTANCE = 1,
++ VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
++ VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
++ VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
++ VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
++} VkVertexInputRate;
+
+ typedef enum {
+ VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
+@@ -509,14 +509,14 @@ typedef enum {
+ } VkPrimitiveTopology;
+
+ typedef enum {
+- VK_FILL_MODE_SOLID = 0,
+- VK_FILL_MODE_WIREFRAME = 1,
+- VK_FILL_MODE_POINTS = 2,
+- VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_SOLID,
+- VK_FILL_MODE_END_RANGE = VK_FILL_MODE_POINTS,
+- VK_FILL_MODE_RANGE_SIZE = (VK_FILL_MODE_POINTS - VK_FILL_MODE_SOLID + 1),
+- VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF
+-} VkFillMode;
++ VK_POLYGON_MODE_FILL = 0,
++ VK_POLYGON_MODE_LINE = 1,
++ VK_POLYGON_MODE_POINT = 2,
++ VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
++ VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
++ VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
++ VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
++} VkPolygonMode;
+
+ typedef enum {
+ VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
+@@ -581,30 +581,30 @@ typedef enum {
+ } VkLogicOp;
+
+ typedef enum {
+- VK_BLEND_ZERO = 0,
+- VK_BLEND_ONE = 1,
+- VK_BLEND_SRC_COLOR = 2,
+- VK_BLEND_ONE_MINUS_SRC_COLOR = 3,
+- VK_BLEND_DST_COLOR = 4,
+- VK_BLEND_ONE_MINUS_DST_COLOR = 5,
+- VK_BLEND_SRC_ALPHA = 6,
+- VK_BLEND_ONE_MINUS_SRC_ALPHA = 7,
+- VK_BLEND_DST_ALPHA = 8,
+- VK_BLEND_ONE_MINUS_DST_ALPHA = 9,
+- VK_BLEND_CONSTANT_COLOR = 10,
+- VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11,
+- VK_BLEND_CONSTANT_ALPHA = 12,
+- VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 13,
+- VK_BLEND_SRC_ALPHA_SATURATE = 14,
+- VK_BLEND_SRC1_COLOR = 15,
+- VK_BLEND_ONE_MINUS_SRC1_COLOR = 16,
+- VK_BLEND_SRC1_ALPHA = 17,
+- VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18,
+- VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO,
+- VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA,
+- VK_BLEND_RANGE_SIZE = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1),
+- VK_BLEND_MAX_ENUM = 0x7FFFFFFF
+-} VkBlend;
++ VK_BLEND_FACTOR_ZERO = 0,
++ VK_BLEND_FACTOR_ONE = 1,
++ VK_BLEND_FACTOR_SRC_COLOR = 2,
++ VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
++ VK_BLEND_FACTOR_DST_COLOR = 4,
++ VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
++ VK_BLEND_FACTOR_SRC_ALPHA = 6,
++ VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
++ VK_BLEND_FACTOR_DST_ALPHA = 8,
++ VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
++ VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
++ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
++ VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
++ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
++ VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
++ VK_BLEND_FACTOR_SRC1_COLOR = 15,
++ VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
++ VK_BLEND_FACTOR_SRC1_ALPHA = 17,
++ VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
++ VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
++ VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
++ VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
++ VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
++} VkBlendFactor;
+
+ typedef enum {
+ VK_BLEND_OP_ADD = 0,
+@@ -743,13 +743,13 @@ typedef enum {
+ } VkIndexType;
+
+ typedef enum {
+- VK_RENDER_PASS_CONTENTS_INLINE = 0,
+- VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
+- VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE,
+- VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
+- VK_RENDER_PASS_CONTENTS_RANGE_SIZE = (VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1),
+- VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
+-} VkRenderPassContents;
++ VK_SUBPASS_CONTENTS_INLINE = 0,
++ VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
++ VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
++ VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
++ VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
++ VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
++} VkSubpassContents;
+
+ typedef VkFlags VkInstanceCreateFlags;
+
+@@ -804,7 +804,7 @@ typedef VkFlags VkSampleCountFlags;
+ typedef enum {
+ VK_QUEUE_GRAPHICS_BIT = 0x00000001,
+ VK_QUEUE_COMPUTE_BIT = 0x00000002,
+- VK_QUEUE_DMA_BIT = 0x00000004,
++ VK_QUEUE_TRANSFER_BIT = 0x00000004,
+ VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
+ } VkQueueFlagBits;
+ typedef VkFlags VkQueueFlags;
+@@ -935,12 +935,12 @@ typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
+ typedef VkFlags VkPipelineColorBlendStateCreateFlags;
+
+ typedef enum {
+- VK_CHANNEL_R_BIT = 0x00000001,
+- VK_CHANNEL_G_BIT = 0x00000002,
+- VK_CHANNEL_B_BIT = 0x00000004,
+- VK_CHANNEL_A_BIT = 0x00000008,
+-} VkChannelFlagBits;
+-typedef VkFlags VkChannelFlags;
++ VK_COLOR_COMPONENT_R_BIT = 0x00000001,
++ VK_COLOR_COMPONENT_G_BIT = 0x00000002,
++ VK_COLOR_COMPONENT_B_BIT = 0x00000004,
++ VK_COLOR_COMPONENT_A_BIT = 0x00000008,
++} VkColorComponentFlagBits;
++typedef VkFlags VkColorComponentFlags;
+ typedef VkFlags VkPipelineDynamicStateCreateFlags;
+ typedef VkFlags VkPipelineLayoutCreateFlags;
+ typedef VkFlags VkShaderStageFlags;
+@@ -1041,7 +1041,7 @@ typedef enum {
+ typedef VkFlags VkStencilFaceFlags;
+
+ typedef enum {
+- VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001,
++ VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
+ } VkQueryControlFlagBits;
+ typedef VkFlags VkQueryControlFlags;
+
+@@ -1129,7 +1129,7 @@ typedef struct {
+ VkBool32 textureCompressionETC2;
+ VkBool32 textureCompressionASTC_LDR;
+ VkBool32 textureCompressionBC;
+- VkBool32 occlusionQueryNonConservative;
++ VkBool32 occlusionQueryPrecise;
+ VkBool32 pipelineStatisticsQuery;
+ VkBool32 vertexPipelineStoresAndAtomics;
+ VkBool32 fragmentStoresAndAtomics;
+@@ -1149,7 +1149,7 @@ typedef struct {
+ VkBool32 shaderInt64;
+ VkBool32 shaderInt16;
+ VkBool32 shaderResourceResidency;
+- VkBool32 shaderResourceMinLOD;
++ VkBool32 shaderResourceMinLod;
+ VkBool32 sparseBinding;
+ VkBool32 sparseResidencyBuffer;
+ VkBool32 sparseResidencyImage2D;
+@@ -1280,8 +1280,8 @@ typedef struct {
+ float pointSizeGranularity;
+ float lineWidthGranularity;
+ VkBool32 strictLines;
+- VkDeviceSize recommendedBufferCopyOffsetAlignment;
+- VkDeviceSize recommendedBufferCopyRowPitchAlignment;
++ VkDeviceSize optimalBufferCopyOffsetAlignment;
++ VkDeviceSize optimalBufferCopyRowPitchAlignment;
+ } VkPhysicalDeviceLimits;
+
+ typedef struct {
+@@ -1295,11 +1295,11 @@ typedef struct {
+ typedef struct {
+ uint32_t apiVersion;
+ uint32_t driverVersion;
+- uint32_t vendorId;
+- uint32_t deviceId;
++ uint32_t vendorID;
++ uint32_t deviceID;
+ VkPhysicalDeviceType deviceType;
+- char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
+- uint8_t pipelineCacheUUID[VK_UUID_LENGTH];
++ char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
++ uint8_t pipelineCacheUUID[VK_UUID_SIZE];
+ VkPhysicalDeviceLimits limits;
+ VkPhysicalDeviceSparseProperties sparseProperties;
+ } VkPhysicalDeviceProperties;
+@@ -1308,6 +1308,7 @@ typedef struct {
+ VkQueueFlags queueFlags;
+ uint32_t queueCount;
+ uint32_t timestampValidBits;
++ VkExtent3D minImageTransferGranularity;
+ } VkQueueFamilyProperties;
+
+ typedef struct {
+@@ -1350,15 +1351,15 @@ typedef struct {
+ } VkDeviceCreateInfo;
+
+ typedef struct {
+- char extensionName[VK_MAX_EXTENSION_NAME];
++ char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
+ uint32_t specVersion;
+ } VkExtensionProperties;
+
+ typedef struct {
+- char layerName[VK_MAX_EXTENSION_NAME];
++ char layerName[VK_MAX_EXTENSION_NAME_SIZE];
+ uint32_t specVersion;
+ uint32_t implementationVersion;
+- char description[VK_MAX_DESCRIPTION];
++ char description[VK_MAX_DESCRIPTION_SIZE];
+ } VkLayerProperties;
+
+ typedef struct {
+@@ -1401,7 +1402,7 @@ typedef struct {
+
+ typedef struct {
+ VkSparseImageFormatProperties formatProperties;
+- uint32_t imageMipTailStartLOD;
++ uint32_t imageMipTailStartLod;
+ VkDeviceSize imageMipTailSize;
+ VkDeviceSize imageMipTailOffset;
+ VkDeviceSize imageMipTailStride;
+@@ -1492,7 +1493,7 @@ typedef struct {
+ const void* pNext;
+ VkQueryPoolCreateFlags flags;
+ VkQueryType queryType;
+- uint32_t slots;
++ uint32_t entryCount;
+ VkQueryPipelineStatisticFlags pipelineStatistics;
+ } VkQueryPoolCreateInfo;
+
+@@ -1543,11 +1544,11 @@ typedef struct {
+ } VkSubresourceLayout;
+
+ typedef struct {
+- VkChannelSwizzle r;
+- VkChannelSwizzle g;
+- VkChannelSwizzle b;
+- VkChannelSwizzle a;
+-} VkChannelMapping;
++ VkComponentSwizzle r;
++ VkComponentSwizzle g;
++ VkComponentSwizzle b;
++ VkComponentSwizzle a;
++} VkComponentMapping;
+
+ typedef struct {
+ VkImageAspectFlags aspectMask;
+@@ -1564,7 +1565,7 @@ typedef struct {
+ VkImage image;
+ VkImageViewType viewType;
+ VkFormat format;
+- VkChannelMapping channels;
++ VkComponentMapping components;
+ VkImageSubresourceRange subresourceRange;
+ } VkImageViewCreateInfo;
+
+@@ -1594,7 +1595,7 @@ typedef struct {
+ } VkPipelineCacheCreateInfo;
+
+ typedef struct {
+- uint32_t constantId;
++ uint32_t constantID;
+ uint32_t offset;
+ size_t size;
+ } VkSpecializationMapEntry;
+@@ -1617,7 +1618,7 @@ typedef struct {
+ typedef struct {
+ uint32_t binding;
+ uint32_t stride;
+- VkVertexInputStepRate stepRate;
++ VkVertexInputRate inputRate;
+ } VkVertexInputBindingDescription;
+
+ typedef struct {
+@@ -1653,8 +1654,8 @@ typedef struct {
+ } VkPipelineTessellationStateCreateInfo;
+
+ typedef struct {
+- float originX;
+- float originY;
++ float x;
++ float y;
+ float width;
+ float height;
+ float minDepth;
+@@ -1692,7 +1693,7 @@ typedef struct {
+ VkPipelineRasterizationStateCreateFlags flags;
+ VkBool32 depthClampEnable;
+ VkBool32 rasterizerDiscardEnable;
+- VkFillMode fillMode;
++ VkPolygonMode polygonMode;
+ VkCullModeFlags cullMode;
+ VkFrontFace frontFace;
+ VkBool32 depthBiasEnable;
+@@ -1715,13 +1716,13 @@ typedef struct {
+ } VkPipelineMultisampleStateCreateInfo;
+
+ typedef struct {
+- VkStencilOp stencilFailOp;
+- VkStencilOp stencilPassOp;
+- VkStencilOp stencilDepthFailOp;
+- VkCompareOp stencilCompareOp;
+- uint32_t stencilCompareMask;
+- uint32_t stencilWriteMask;
+- uint32_t stencilReference;
++ VkStencilOp failOp;
++ VkStencilOp passOp;
++ VkStencilOp depthFailOp;
++ VkCompareOp compareOp;
++ uint32_t compareMask;
++ uint32_t writeMask;
++ uint32_t reference;
+ } VkStencilOpState;
+
+ typedef struct {
+@@ -1741,13 +1742,13 @@ typedef struct {
+
+ typedef struct {
+ VkBool32 blendEnable;
+- VkBlend srcBlendColor;
+- VkBlend dstBlendColor;
+- VkBlendOp blendOpColor;
+- VkBlend srcBlendAlpha;
+- VkBlend dstBlendAlpha;
+- VkBlendOp blendOpAlpha;
+- VkChannelFlags channelWriteMask;
++ VkBlendFactor srcColorBlendFactor;
++ VkBlendFactor dstColorBlendFactor;
++ VkBlendOp colorBlendOp;
++ VkBlendFactor srcAlphaBlendFactor;
++ VkBlendFactor dstAlphaBlendFactor;
++ VkBlendOp alphaBlendOp;
++ VkColorComponentFlags colorWriteMask;
+ } VkPipelineColorBlendAttachmentState;
+
+ typedef struct {
+@@ -1855,15 +1856,15 @@ typedef struct {
+ typedef struct {
+ VkDescriptorType type;
+ uint32_t descriptorCount;
+-} VkDescriptorTypeCount;
++} VkDescriptorPoolSize;
+
+ typedef struct {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorPoolCreateFlags flags;
+ uint32_t maxSets;
+- uint32_t typeCount;
+- const VkDescriptorTypeCount* pTypeCounts;
++ uint32_t poolSizeCount;
++ const VkDescriptorPoolSize* pPoolSizes;
+ } VkDescriptorPoolCreateInfo;
+
+ typedef struct {
+@@ -2006,25 +2007,25 @@ typedef struct {
+ } VkBufferCopy;
+
+ typedef struct {
+- VkImageAspectFlags aspect;
++ VkImageAspectFlags aspectMask;
+ uint32_t mipLevel;
+ uint32_t baseArrayLayer;
+ uint32_t layerCount;
+-} VkImageSubresourceCopy;
++} VkImageSubresourceLayers;
+
+ typedef struct {
+- VkImageSubresourceCopy srcSubresource;
++ VkImageSubresourceLayers srcSubresource;
+ VkOffset3D srcOffset;
+- VkImageSubresourceCopy dstSubresource;
++ VkImageSubresourceLayers dstSubresource;
+ VkOffset3D dstOffset;
+ VkExtent3D extent;
+ } VkImageCopy;
+
+ typedef struct {
+- VkImageSubresourceCopy srcSubresource;
++ VkImageSubresourceLayers srcSubresource;
+ VkOffset3D srcOffset;
+ VkExtent3D srcExtent;
+- VkImageSubresourceCopy dstSubresource;
++ VkImageSubresourceLayers dstSubresource;
+ VkOffset3D dstOffset;
+ VkExtent3D dstExtent;
+ } VkImageBlit;
+@@ -2033,7 +2034,7 @@ typedef struct {
+ VkDeviceSize bufferOffset;
+ uint32_t bufferRowLength;
+ uint32_t bufferImageHeight;
+- VkImageSubresourceCopy imageSubresource;
++ VkImageSubresourceLayers imageSubresource;
+ VkOffset3D imageOffset;
+ VkExtent3D imageExtent;
+ } VkBufferImageCopy;
+@@ -2067,9 +2068,9 @@ typedef struct {
+ } VkClearRect;
+
+ typedef struct {
+- VkImageSubresourceCopy srcSubresource;
++ VkImageSubresourceLayers srcSubresource;
+ VkOffset3D srcOffset;
+- VkImageSubresourceCopy dstSubresource;
++ VkImageSubresourceLayers dstSubresource;
+ VkOffset3D dstOffset;
+ VkExtent3D extent;
+ } VkImageResolve;
+@@ -2226,10 +2227,10 @@ typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRender
+ typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
+ typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+ typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
+-typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool CommandPool, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool CommandPool, VkCommandPoolResetFlags flags);
++typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
+ typedef VkResult (VKAPI *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
+-typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool CommandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
++typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
+ typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+ typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
+ typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
+@@ -2240,9 +2241,9 @@ typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float
+ typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
+ typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
+ typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
+-typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
+-typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
+-typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
++typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
++typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
++typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
+ typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+ typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+ typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+@@ -2267,14 +2268,14 @@ typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent e
+ typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+ typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
+ typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
+-typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+-typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot);
++typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags);
++typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry);
+ typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+-typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
++typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry);
+ typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+ typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values);
+-typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+-typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkRenderPassContents contents);
++typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
++typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
+ typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
+ typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers);
+
+@@ -2762,12 +2763,12 @@ VkResult VKAPI vkCreateCommandPool(
+
+ void VKAPI vkDestroyCommandPool(
+ VkDevice device,
+- VkCommandPool CommandPool,
++ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator);
+
+ VkResult VKAPI vkResetCommandPool(
+ VkDevice device,
+- VkCommandPool CommandPool,
++ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags);
+
+ VkResult VKAPI vkAllocateCommandBuffers(
+@@ -2777,7 +2778,7 @@ VkResult VKAPI vkAllocateCommandBuffers(
+
+ void VKAPI vkFreeCommandBuffers(
+ VkDevice device,
+- VkCommandPool CommandPool,
++ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers);
+
+@@ -2829,17 +2830,17 @@ void VKAPI vkCmdSetDepthBounds(
+ void VKAPI vkCmdSetStencilCompareMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+- uint32_t stencilCompareMask);
++ uint32_t compareMask);
+
+ void VKAPI vkCmdSetStencilWriteMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+- uint32_t stencilWriteMask);
++ uint32_t writeMask);
+
+ void VKAPI vkCmdSetStencilReference(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+- uint32_t stencilReference);
++ uint32_t reference);
+
+ void VKAPI vkCmdBindDescriptorSets(
+ VkCommandBuffer commandBuffer,
+@@ -3022,13 +3023,13 @@ void VKAPI vkCmdPipelineBarrier(
+ void VKAPI vkCmdBeginQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+- uint32_t slot,
++ uint32_t entry,
+ VkQueryControlFlags flags);
+
+ void VKAPI vkCmdEndQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+- uint32_t slot);
++ uint32_t entry);
+
+ void VKAPI vkCmdResetQueryPool(
+ VkCommandBuffer commandBuffer,
+@@ -3040,7 +3041,7 @@ void VKAPI vkCmdWriteTimestamp(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+- uint32_t slot);
++ uint32_t entry);
+
+ void VKAPI vkCmdCopyQueryPoolResults(
+ VkCommandBuffer commandBuffer,
+@@ -3063,11 +3064,11 @@ void VKAPI vkCmdPushConstants(
+ void VKAPI vkCmdBeginRenderPass(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+- VkRenderPassContents contents);
++ VkSubpassContents contents);
+
+ void VKAPI vkCmdNextSubpass(
+ VkCommandBuffer commandBuffer,
+- VkRenderPassContents contents);
++ VkSubpassContents contents);
+
+ void VKAPI vkCmdEndRenderPass(
+ VkCommandBuffer commandBuffer);
+@@ -3431,7 +3432,7 @@ typedef struct {
+ #define VK_EXT_KHR_XLIB_SURFACE_EXTENSION_NAME "vk_ext_khr_xlib_surface"
+
+ typedef VkResult (VKAPI *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, VkSurfaceKHR* pSurface);
+-typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualId);
++typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
+
+ #ifdef VK_PROTOTYPES
+ VkResult VKAPI vkCreateXlibSurfaceKHR(
+@@ -3444,7 +3445,7 @@ VkBool32 VKAPI vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display* dpy,
+- VisualID visualId);
++ VisualID visualID);
+ #endif
+ #endif /* VK_USE_PLATFORM_XLIB_KHR */
+
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index a2b4c0f..2b7faa9 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -552,18 +552,18 @@ void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, fl
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
+- GetVtbl(commandBuffer).CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
++void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
++ GetVtbl(commandBuffer).CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
+- GetVtbl(commandBuffer).CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
++void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
++ GetVtbl(commandBuffer).CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
+- GetVtbl(commandBuffer).CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
++void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
++ GetVtbl(commandBuffer).CmdSetStencilReference(commandBuffer, faceMask, reference);
+ }
+
+ __attribute__((visibility("default")))
+@@ -687,13 +687,13 @@ void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags sr
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
+- GetVtbl(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, slot, flags);
++void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags) {
++ GetVtbl(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, entry, flags);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
+- GetVtbl(commandBuffer).CmdEndQuery(commandBuffer, queryPool, slot);
++void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry) {
++ GetVtbl(commandBuffer).CmdEndQuery(commandBuffer, queryPool, entry);
+ }
+
+ __attribute__((visibility("default")))
+@@ -702,8 +702,8 @@ void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, u
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
+- GetVtbl(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
++void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry) {
++ GetVtbl(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, entry);
+ }
+
+ __attribute__((visibility("default")))
+@@ -717,12 +717,12 @@ void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
++void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
+ GetVtbl(commandBuffer).CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkRenderPassContents contents) {
++void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+ GetVtbl(commandBuffer).CmdNextSubpass(commandBuffer, contents);
+ }
+
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index b2b905f..85d018b 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -266,8 +266,8 @@ void GetPhysicalDeviceProperties(VkPhysicalDevice,
+ VkPhysicalDeviceProperties* properties) {
+ properties->apiVersion = VK_API_VERSION;
+ properties->driverVersion = VK_MAKE_VERSION(0, 0, 1);
+- properties->vendorId = 0;
+- properties->deviceId = 0;
++ properties->vendorID = 0;
++ properties->deviceID = 0;
+ properties->deviceType = VK_PHYSICAL_DEVICE_TYPE_OTHER;
+ strcpy(properties->deviceName, "Android Vulkan Null Driver");
+ memset(properties->pipelineCacheUUID, 0,
+@@ -279,8 +279,8 @@ void GetPhysicalDeviceQueueFamilyProperties(
+ uint32_t* count,
+ VkQueueFamilyProperties* properties) {
+ if (properties) {
+- properties->queueFlags =
+- VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_DMA_BIT;
++ properties->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT |
++ VK_QUEUE_TRANSFER_BIT;
+ properties->queueCount = 1;
+ properties->timestampValidBits = 64;
+ }
+@@ -1077,10 +1077,10 @@ void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, u
+ void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
+ }
+
+-void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
++void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
+ }
+
+-void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkRenderPassContents contents) {
++void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkSubpassContents contents) {
+ }
+
+ void CmdEndRenderPass(VkCommandBuffer cmdBuffer) {
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 939a559..91b8d34 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -161,8 +161,8 @@ void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_
+ void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
+ void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
+ void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
+-void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+-void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkRenderPassContents contents);
++void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
++void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkSubpassContents contents);
+ void CmdEndRenderPass(VkCommandBuffer cmdBuffer);
+ void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers);
+
+diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
+index 1920d6b..c63dca4 100644
+--- a/vulkan/tools/vkinfo.cpp
++++ b/vulkan/tools/vkinfo.cpp
+@@ -75,8 +75,8 @@ const char* VkQueueFlagBitStr(VkQueueFlagBits bit) {
+ return "GRAPHICS";
+ case VK_QUEUE_COMPUTE_BIT:
+ return "COMPUTE";
+- case VK_QUEUE_DMA_BIT:
+- return "DMA";
++ case VK_QUEUE_TRANSFER_BIT:
++ return "TRANSFER";
+ case VK_QUEUE_SPARSE_BINDING_BIT:
+ return "SPARSE";
+ }
+@@ -91,8 +91,8 @@ void DumpPhysicalDevice(uint32_t idx, VkPhysicalDevice pdev) {
+ printf(" %u: \"%s\" (%s) %u.%u.%u/%#x [%04x:%04x]\n", idx,
+ props.deviceName, VkPhysicalDeviceTypeStr(props.deviceType),
+ (props.apiVersion >> 22) & 0x3FF, (props.apiVersion >> 12) & 0x3FF,
+- (props.apiVersion >> 0) & 0xFFF, props.driverVersion, props.vendorId,
+- props.deviceId);
++ (props.apiVersion >> 0) & 0xFFF, props.driverVersion, props.vendorID,
++ props.deviceID);
+
+ VkPhysicalDeviceMemoryProperties mem_props;
+ vkGetPhysicalDeviceMemoryProperties(pdev, &mem_props);
+--
+2.4.0
+
--- /dev/null
+From 2afbe83fe000204ab6f44e11b55bbad700dac27a Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 30 Nov 2015 00:42:57 -0800
+Subject: [PATCH 21/30] vulkan: Update from version 0.198.0 to 0.200.0
+
+Change-Id: I071a9143332dd8b8c2ef899105073ed8791fc5db
+---
+ vulkan/api/vulkan.api | 373 +++++------
+ vulkan/include/vulkan/vk_android_native_buffer.h | 93 +++
+ .../include/vulkan/vk_ext_android_native_buffer.h | 93 ---
+ vulkan/include/vulkan/vulkan.h | 679 ++++++++++-----------
+ vulkan/libvulkan/entry.cpp | 10 -
+ vulkan/libvulkan/entry.cpp.tmpl | 6 +-
+ vulkan/libvulkan/get_proc_addr.cpp | 16 +-
+ vulkan/libvulkan/get_proc_addr.cpp.tmpl | 16 +-
+ vulkan/libvulkan/loader.h | 4 +-
+ vulkan/nulldrv/null_driver.cpp | 12 -
+ vulkan/nulldrv/null_driver.h | 4 +-
+ vulkan/nulldrv/null_driver_gen.cpp | 2 -
+ 12 files changed, 595 insertions(+), 713 deletions(-)
+ create mode 100644 vulkan/include/vulkan/vk_android_native_buffer.h
+ delete mode 100644 vulkan/include/vulkan/vk_ext_android_native_buffer.h
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index ab887fa..0296b0f 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 198
++define VERSION_MINOR 200
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -45,45 +45,45 @@ define VK_FALSE 0
+ // API keyword, but needs special handling by some templates
+ define NULL_HANDLE 0
+
+-@extension("VK_EXT_KHR_surface") define VK_EXT_KHR_SURFACE_REVISION 20
+-@extension("VK_EXT_KHR_surface") define VK_EXT_KHR_SURFACE_EXTENSION_NUMBER 1
+-@extension("VK_EXT_KHR_surface") define VK_EXT_KHR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_surface"
++@extension("VK_KHR_surface") define VK_KHR_SURFACE_REVISION 22
++@extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NUMBER 1
++@extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"
+
+-@extension("VK_EXT_KHR_swapchain") define VK_EXT_KHR_SWAPCHAIN_REVISION 62
+-@extension("VK_EXT_KHR_swapchain") define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+-@extension("VK_EXT_KHR_swapchain") define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
++@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_REVISION 64
++@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
++@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
+
+-@extension("VK_EXT_KHR_display") define VK_EXT_KHR_DISPLAY_REVISION 17
+-@extension("VK_EXT_KHR_display") define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 3
+-@extension("VK_EXT_KHR_display") define VK_EXT_KHR_DISPLAY_EXTENSION_NAME "VK_EXT_KHR_display"
++@extension("VK_KHR_display") define VK_KHR_DISPLAY_REVISION 18
++@extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NUMBER 3
++@extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"
+
+-@extension("VK_EXT_KHR_display_swapchain") define VK_EXT_KHR_DISPLAY_REVISION 6
+-@extension("VK_EXT_KHR_display_swapchain") define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 4
+-@extension("VK_EXT_KHR_display_swapchain") define VK_EXT_KHR_DISPLAY_EXTENSION_NAME "VK_EXT_KHR_display_swapchain"
++@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_REVISION 7
++@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_EXTENSION_NUMBER 4
++@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display_swapchain"
+
+-@extension("VK_EXT_KHR_xlib_surface") define VK_EXT_KHR_XLIB_SURFACE_REVISION 3
+-@extension("VK_EXT_KHR_xlib_surface") define VK_EXT_KHR_XLIB_SURFACE_NUMBER 5
+-@extension("VK_EXT_KHR_xlib_surface") define VK_EXT_KHR_XLIB_SURFACE_NAME "VK_EXT_KHR_xlib_surface"
++@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_REVISION 4
++@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_NUMBER 5
++@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_NAME "VK_KHR_xlib_surface"
+
+-@extension("VK_EXT_KHR_xcb_surface") define VK_EXT_KHR_XCB_SURFACE_REVISION 3
+-@extension("VK_EXT_KHR_xcb_surface") define VK_EXT_KHR_XCB_SURFACE_NUMBER 6
+-@extension("VK_EXT_KHR_xcb_surface") define VK_EXT_KHR_XCB_SURFACE_NAME "VK_EXT_KHR_xcb_surface"
++@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_REVISION 4
++@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_NUMBER 6
++@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_NAME "VK_KHR_xcb_surface"
+
+-@extension("VK_EXT_KHR_wayland_surface") define VK_EXT_KHR_WAYLAND_SURFACE_REVISION 2
+-@extension("VK_EXT_KHR_wayland_surface") define VK_EXT_KHR_WAYLAND_SURFACE_NUMBER 7
+-@extension("VK_EXT_KHR_wayland_surface") define VK_EXT_KHR_WAYLAND_SURFACE_NAME "VK_EXT_KHR_wayland_surface"
++@extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_REVISION 3
++@extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_NUMBER 7
++@extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_NAME "VK_KHR_wayland_surface"
+
+-@extension("VK_EXT_KHR_mir_surface") define VK_EXT_KHR_MIR_SURFACE_REVISION 2
+-@extension("VK_EXT_KHR_mir_surface") define VK_EXT_KHR_MIR_SURFACE_NUMBER 8
+-@extension("VK_EXT_KHR_mir_surface") define VK_EXT_KHR_MIR_SURFACE_NAME "VK_EXT_KHR_mir_surface"
++@extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_REVISION 3
++@extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_NUMBER 8
++@extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_NAME "VK_KHR_mir_surface"
+
+-@extension("VK_EXT_KHR_android_surface") define VK_EXT_KHR_ANDROID_SURFACE_REVISION 1
+-@extension("VK_EXT_KHR_android_surface") define VK_EXT_KHR_ANDROID_SURFACE_NUMBER 8
+-@extension("VK_EXT_KHR_android_surface") define VK_EXT_KHR_ANDROID_SURFACE_NAME "VK_EXT_KHR_android_surface"
++@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_REVISION 2
++@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_NUMBER 8
++@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_NAME "VK_KHR_android_surface"
+
+-@extension("VK_EXT_KHR_win32_surface") define VK_EXT_KHR_WIN32_SURFACE_REVISION 2
+-@extension("VK_EXT_KHR_win32_surface") define VK_EXT_KHR_WIN32_SURFACE_NUMBER 9
+-@extension("VK_EXT_KHR_win32_surface") define VK_EXT_KHR_WIN32_SURFACE_NAME "VK_EXT_KHR_win32_surface"
++@extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_REVISION 3
++@extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_NUMBER 9
++@extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_NAME "VK_KHR_win32_surface"
+
+
+ /////////////
+@@ -110,7 +110,6 @@ type u32 VkSampleMask
+ @nonDispatchHandle type u64 VkImage
+ @nonDispatchHandle type u64 VkImageView
+ @nonDispatchHandle type u64 VkShaderModule
+-@nonDispatchHandle type u64 VkShader
+ @nonDispatchHandle type u64 VkPipeline
+ @nonDispatchHandle type u64 VkPipelineLayout
+ @nonDispatchHandle type u64 VkSampler
+@@ -125,12 +124,12 @@ type u32 VkSampleMask
+ @nonDispatchHandle type u64 VkRenderPass
+ @nonDispatchHandle type u64 VkPipelineCache
+
+-@extension("VK_EXT_KHR_surface") @nonDispatchHandle type u64 VkSurfaceKHR
++@extension("VK_KHR_surface") @nonDispatchHandle type u64 VkSurfaceKHR
+
+-@extension("VK_EXT_KHR_swapchain") @nonDispatchHandle type u64 VkSwapchainKHR
++@extension("VK_KHR_swapchain") @nonDispatchHandle type u64 VkSwapchainKHR
+
+-@extension("VK_EXT_KHR_display") @nonDispatchHandle type u64 VkDisplayKHR
+-@extension("VK_EXT_KHR_display") @nonDispatchHandle type u64 VkDisplayModeKHR
++@extension("VK_KHR_display") @nonDispatchHandle type u64 VkDisplayKHR
++@extension("VK_KHR_display") @nonDispatchHandle type u64 VkDisplayModeKHR
+
+
+ /////////////
+@@ -148,7 +147,7 @@ enum VkImageLayout {
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 0x00000007, /// Optimal layout when image is used only as destination of transfer operations
+ VK_IMAGE_LAYOUT_PREINITIALIZED = 0x00000008, /// Initial layout used when the data is populated by the CPU
+
+- //@extension("VK_EXT_KHR_swapchain")
++ //@extension("VK_KHR_swapchain")
+ VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 0xc0000802,
+ }
+
+@@ -359,7 +358,7 @@ enum VkLogicOp {
+ }
+
+ enum VkSystemAllocationScope {
+- VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION = 0x00000000,
++ VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0x00000000,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 0x00000001,
+ VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 0x00000002,
+ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 0x00000003,
+@@ -580,47 +579,46 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
+ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
+- VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 17,
+- VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 18,
+- VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19,
+- VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 20,
+- VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 21,
+- VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 22,
+- VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 23,
+- VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 24,
+- VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 25,
+- VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 26,
+- VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
+- VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 28,
+- VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 29,
+- VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 30,
+- VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 31,
+- VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 32,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 33,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 34,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 35,
+- VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 36,
+- VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 37,
+- VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 38,
+- VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 39,
+- VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 40,
+- VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 41,
+- VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
+- VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
+- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
+- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
+- VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
+- VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 47,
+- VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 48,
+-
+- //@extension("VK_EXT_KHR_swapchain")
++ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
++ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
++ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
++ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
++ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
++ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
++ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
++ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
++ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
++ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
++ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
++ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
++ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
++ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
++ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 34,
++ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
++ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
++ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
++ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
++ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
++ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 40,
++ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 41,
++ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 42,
++ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43,
++ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44,
++ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45,
++ VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 46,
++ VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 47,
++
++ //@extension("VK_KHR_swapchain")
+ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 0xc0000801,
+
+- //@extension("VK_EXT_KHR_display")
++ //@extension("VK_KHR_display")
+ VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 0xc0000c00,
+ VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 0xc0000c01,
+
+- //@extension("VK_EXT_KHR_display_swapchain")
++ //@extension("VK_KHR_display_swapchain")
+ VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR = 0xc0001000,
+ VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR = 0xc0001001,
+ }
+@@ -641,7 +639,7 @@ enum VkResult {
+ VK_EVENT_RESET = 0x00000004,
+ VK_INCOMPLETE = 0x00000005,
+
+- //@extension("VK_EXT_KHR_swapchain")
++ //@extension("VK_KHR_swapchain")
+ VK_SUBOPTIMAL_KHR = 0x40000403,
+
+ // Error codes (negative values)
+@@ -655,16 +653,16 @@ enum VkResult {
+ VK_ERROR_FEATURE_NOT_PRESENT = 0xFFFFFFF8,
+ VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF7,
+
+- //@extension("VK_EXT_KHR_surface")
++ //@extension("VK_KHR_surface")
+ VK_ERROR_SURFACE_LOST_KHR = 0xC0000400,
+
+- //@extension("VK_EXT_KHR_swapchain")
++ //@extension("VK_KHR_swapchain")
+ VK_ERROR_OUT_OF_DATE_KHR = 0xC0000804,
+
+- //@extension("VK_EXT_KHR_display_swapchain")
++ //@extension("VK_KHR_display_swapchain")
+ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC0001002,
+
+- //@extension("VK_EXT_KHR_android_surface")
++ //@extension("VK_KHR_android_surface")
+ VK_ERROR_INVALID_ANDROID_WINDOW_KHR = 0xC002400,
+ VK_ERROR_ANDROID_WINDOW_IN_USE_KHR = 0xC002401,
+ }
+@@ -681,7 +679,7 @@ enum VkDynamicState {
+ VK_DYNAMIC_STATE_STENCIL_REFERENCE = 0x00000008,
+ }
+
+-@extension("VK_EXT_KHR_surface")
++@extension("VK_KHR_surface")
+ enum VkSurfaceTransformKHR {
+ VK_SURFACE_TRANSFORM_NONE_KHR = 0x00000000,
+ VK_SURFACE_TRANSFORM_ROT90_KHR = 0x00000001,
+@@ -694,7 +692,7 @@ enum VkSurfaceTransformKHR {
+ VK_SURFACE_TRANSFORM_INHERIT_KHR = 0x00000008,
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ enum VkPresentModeKHR {
+ VK_PRESENT_MODE_IMMEDIATE_KHR = 0x00000000,
+ VK_PRESENT_MODE_MAILBOX_KHR = 0x00000001,
+@@ -702,7 +700,7 @@ enum VkPresentModeKHR {
+ VK_PRESENT_MODE_FIFO_RELAXED_KHR = 0x00000003,
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ enum VkColorSpaceKHR {
+ VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0x00000000,
+ }
+@@ -736,29 +734,26 @@ bitfield VkMemoryHeapFlagBits {
+ VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
+ }
+
+-/// Memory output flags passed to resource transition commands
+-type VkFlags VkMemoryOutputFlags
+-bitfield VkMemoryOutputFlagBits {
+- VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, /// Controls output coherency of host writes
+- VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, /// Controls output coherency of generic shader writes
+- VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, /// Controls output coherency of color attachment writes
+- VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, /// Controls output coherency of depth/stencil attachment writes
+- VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010, /// Controls output coherency of transfer operations
+-}
+-
+-/// Memory input flags passed to resource transition commands
+-type VkFlags VkMemoryInputFlags
+-bitfield VkMemoryInputFlagBits {
+- VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, /// Controls input coherency of host reads
+- VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, /// Controls input coherency of indirect command reads
+- VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, /// Controls input coherency of index fetches
+- VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, /// Controls input coherency of vertex attribute fetches
+- VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, /// Controls input coherency of uniform buffer reads
+- VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, /// Controls input coherency of generic shader reads
+- VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, /// Controls input coherency of color attachment reads
+- VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, /// Controls input coherency of depth/stencil attachment reads
+- VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100, /// Controls input coherency of input attachment reads
+- VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200, /// Controls input coherency of transfer operations
++/// Access flags
++type VkFlags VkAccessFlags
++bitfield VkAccessFlagBits {
++ VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
++ VK_ACCESS_INDEX_READ_BIT = 0x00000002,
++ VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
++ VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
++ VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
++ VK_ACCESS_SHADER_READ_BIT = 0x00000020,
++ VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
++ VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
++ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
++ VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
++ VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
++ VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
++ VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
++ VK_ACCESS_HOST_READ_BIT = 0x00002000,
++ VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
++ VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
++ VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
+ }
+
+ /// Buffer usage flags
+@@ -902,11 +897,6 @@ type VkFlags VkShaderModuleCreateFlags
+ //bitfield VkShaderModuleCreateFlagBits {
+ //}
+
+-/// Shader creation flags
+-type VkFlags VkShaderCreateFlags
+-//bitfield VkShaderCreateFlagBits {
+-//}
+-
+ /// Event creation flags
+ type VkFlags VkEventCreateFlags
+ //bitfield VkEventCreateFlagBits {
+@@ -1153,9 +1143,9 @@ bitfield VkCullModeFlagBits {
+ VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ type VkFlags VkSurfaceTransformFlagsKHR
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ bitfield VkSurfaceTransformFlagBitsKHR {
+ VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
+ VK_SURFACE_TRANSFORM_ROT90_BIT_KHR = 0x00000002,
+@@ -1168,9 +1158,9 @@ bitfield VkSurfaceTransformFlagBitsKHR {
+ VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ type VkFlags VkCompositeAlphaFlagsKHR
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ bitfield VkCompositeAlphaFlagBitsKHR {
+ VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
+ VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
+@@ -1178,9 +1168,9 @@ bitfield VkCompositeAlphaFlagBitsKHR {
+ VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ type VkFlags VkDisplayPlaneAlphaFlagsKHR
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ bitfield VkDisplayPlaneAlphaFlagBitsKHR {
+ VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000001,
+ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000002,
+@@ -1356,7 +1346,7 @@ class VkMemoryRequirements {
+ }
+
+ class VkSparseImageFormatProperties {
+- VkImageAspectFlagBits aspect
++ VkImageAspectFlagBits aspectMask
+ VkExtent3D imageGranularity
+ VkSparseImageFormatFlags flags
+ }
+@@ -1460,7 +1450,7 @@ class VkBufferViewCreateInfo {
+ }
+
+ class VkImageSubresource {
+- VkImageAspectFlagBits aspect
++ VkImageAspectFlagBits aspectMask
+ u32 mipLevel
+ u32 arrayLayer
+ }
+@@ -1476,15 +1466,15 @@ class VkImageSubresourceRange {
+ class VkMemoryBarrier {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER
+ const void* pNext /// Pointer to next structure.
+- VkMemoryOutputFlags outputMask /// Outputs the barrier should sync
+- VkMemoryInputFlags inputMask /// Inputs the barrier should sync to
++ VkAccessFlags srcAccessMask
++ VkAccessFlags dstAccessMask
+ }
+
+ class VkBufferMemoryBarrier {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
+ const void* pNext /// Pointer to next structure.
+- VkMemoryOutputFlags outputMask /// Outputs the barrier should sync
+- VkMemoryInputFlags inputMask /// Inputs the barrier should sync to
++ VkAccessFlags srcAccessMask
++ VkAccessFlags dstAccessMask
+ u32 srcQueueFamilyIndex /// Queue family to transition ownership from
+ u32 dstQueueFamilyIndex /// Queue family to transition ownership to
+ VkBuffer buffer /// Buffer to sync
+@@ -1495,8 +1485,8 @@ class VkBufferMemoryBarrier {
+ class VkImageMemoryBarrier {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
+ const void* pNext /// Pointer to next structure.
+- VkMemoryOutputFlags outputMask /// Outputs the barrier should sync
+- VkMemoryInputFlags inputMask /// Inputs the barrier should sync to
++ VkAccessFlags srcAccessMask
++ VkAccessFlags dstAccessMask
+ VkImageLayout oldLayout /// Current layout of the image
+ VkImageLayout newLayout /// New layout to transition the image to
+ u32 srcQueueFamilyIndex /// Queue family to transition ownership from
+@@ -1646,15 +1636,6 @@ class VkShaderModuleCreateInfo {
+ const u32* pCode /// Binary code of size codeSize
+ }
+
+-class VkShaderCreateInfo {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO
+- const void* pNext /// Pointer to next structure
+- VkShaderCreateFlags flags /// Reserved
+- VkShaderModule module /// Module containing entry point
+- const char* pName /// Null-terminated entry point name
+- VkShaderStageFlagBits stage
+-}
+-
+ class VkDescriptorSetLayoutBinding {
+ VkDescriptorType descriptorType /// Type of the descriptors in this binding
+ u32 arraySize /// Number of descriptors in this binding
+@@ -1667,7 +1648,7 @@ class VkDescriptorSetLayoutCreateInfo {
+ const void* pNext /// Pointer to next structure
+ VkDescriptorSetLayoutCreateFlags flags
+ u32 bindingCount /// Number of bindings in the descriptor set layout
+- const VkDescriptorSetLayoutBinding* pBindings /// Array of descriptor set layout bindings
++ const VkDescriptorSetLayoutBinding* pBinding /// Array of descriptor set layout bindings
+ }
+
+ class VkDescriptorPoolSize {
+@@ -1709,7 +1690,9 @@ class VkPipelineShaderStageCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+ VkPipelineShaderStageCreateFlags flags
+- VkShader shader
++ VkShaderStageFlagBits stage
++ VkShaderModule module
++ const char* pName
+ const VkSpecializationInfo* pSpecializationInfo
+ }
+
+@@ -2015,8 +1998,8 @@ class VkSubpassDependency {
+ u32 dstSubpass
+ VkPipelineStageFlags srcStageMask
+ VkPipelineStageFlags dstStageMask
+- VkMemoryOutputFlags outputMask
+- VkMemoryInputFlags inputMask
++ VkAccessFlags srcAccessMask
++ VkAccessFlags dstAccessMask
+ VkDependencyFlags dependencyFlags
+ }
+
+@@ -2279,7 +2262,7 @@ class VkDispatchIndirectCommand {
+ u32 z
+ }
+
+-@extension("VK_EXT_KHR_surface")
++@extension("VK_KHR_surface")
+ class VkSurfaceCapabilitiesKHR {
+ u32 minImageCount
+ u32 maxImageCount
+@@ -2293,13 +2276,13 @@ class VkSurfaceCapabilitiesKHR {
+ VkImageUsageFlags supportedUsageFlags
+ }
+
+-@extension("VK_EXT_KHR_surface")
++@extension("VK_KHR_surface")
+ class VkSurfaceFormatKHR {
+ VkFormat format
+ VkColorSpaceKHR colorSpace
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ class VkSwapchainCreateInfoKHR {
+ VkStructureType sType
+ const void* pNext
+@@ -2320,7 +2303,7 @@ class VkSwapchainCreateInfoKHR {
+ VkBool32 clipped
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ class VkPresentInfoKHR {
+ VkStructureType sType
+ const void* pNext
+@@ -2331,7 +2314,7 @@ class VkPresentInfoKHR {
+ const u32* imageIndices
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ class VkDisplayPropertiesKHR {
+ VkDisplayKHR display
+ const char* displayName
+@@ -2342,32 +2325,32 @@ class VkDisplayPropertiesKHR {
+ VkBool32 persistentContent
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ class VkDisplayModeParametersKHR {
+ VkExtent2D visibleRegion
+ u32 refreshRate
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ class VkDisplayModePropertiesKHR {
+ VkDisplayModeKHR displayMode
+ VkDisplayModeParametersKHR parameters
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ class VkDisplayModeCreateInfoKHR {
+ VkStructureType sType
+ const void* pNext
+ VkDisplayModeParametersKHR parameters
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ class VkDisplayPlanePropertiesKHR {
+ VkDisplayKHR currentDisplay
+ u32 currentStackIndex
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ class VkDisplayPlaneCapabilitiesKHR {
+ VkDisplayPlaneAlphaFlagsKHR supportedAlpha
+ VkOffset2D minSrcPosition
+@@ -2380,7 +2363,7 @@ class VkDisplayPlaneCapabilitiesKHR {
+ VkExtent2D maxDstExtent
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ class VkDisplaySurfaceCreateInfoKHR {
+ VkStructureType sType
+ const void* pNext
+@@ -2393,14 +2376,14 @@ class VkDisplaySurfaceCreateInfoKHR {
+ VkExtent2D imageSize
+ }
+
+-@extension("VK_EXT_KHR_display_swapchain")
++@extension("VK_KHR_display_swapchain")
+ class VkDisplaySwapchainCreateInfoKHR {
+ VkStructureType sType
+ const void* pNext
+ const VkSwapchainCreateInfoKHR* pNextSwapchainCreateInfo
+ }
+
+-@extension("VK_EXT_KHR_display_swapchain")
++@extension("VK_KHR_display_swapchain")
+ class VkDisplayPresentInfoKHR {
+ VkStructureType sType
+ const void* pNext
+@@ -3378,34 +3361,6 @@ cmd void vkDestroyShaderModule(
+ State.ShaderModules[shaderModule] = null
+ }
+
+-@threadSafety("system")
+-cmd VkResult vkCreateShader(
+- VkDevice device,
+- const VkShaderCreateInfo* pCreateInfo,
+- const VkAllocationCallbacks* pAllocator,
+- VkShader* pShader) {
+- assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_CREATE_INFO)
+- deviceObject := GetDevice(device)
+-
+- shader := ?
+- pShader[0] = shader
+- State.Shaders[shader] = new!ShaderObject(device: device)
+-
+- return ?
+-}
+-
+-@threadSafety("system")
+-cmd void vkDestroyShader(
+- VkDevice device,
+- VkShader shader,
+- const VkAllocationCallbacks* pAllocator) {
+- deviceObject := GetDevice(device)
+- shaderObject := GetShader(shader)
+- assert(shaderObject.device == device)
+-
+- State.Shaders[shader] = null
+-}
+-
+
+ // Pipeline functions
+
+@@ -4625,7 +4580,7 @@ cmd void vkCmdExecuteCommands(
+ }
+ }
+
+-@extension("VK_EXT_KHR_surface")
++@extension("VK_KHR_surface")
+ cmd void vkDestroySurfaceKHR(
+ VkInstance instance,
+ VkSurfaceKHR surface) {
+@@ -4636,7 +4591,7 @@ cmd void vkDestroySurfaceKHR(
+ State.Surfaces[surface] = null
+ }
+
+-@extension("VK_EXT_KHR_surface")
++@extension("VK_KHR_surface")
+ cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ u32 queueFamilyIndex,
+@@ -4647,7 +4602,7 @@ cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_surface")
++@extension("VK_KHR_surface")
+ cmd VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+@@ -4660,7 +4615,7 @@ cmd VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_surface")
++@extension("VK_KHR_surface")
+ cmd VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+@@ -4680,7 +4635,7 @@ cmd VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_surface")
++@extension("VK_KHR_surface")
+ cmd VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+@@ -4700,7 +4655,7 @@ cmd VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ cmd VkResult vkCreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+@@ -4715,7 +4670,7 @@ cmd VkResult vkCreateSwapchainKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ cmd void vkDestroySwapchainKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain) {
+@@ -4726,7 +4681,7 @@ cmd void vkDestroySwapchainKHR(
+ State.Swapchains[swapchain] = null
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ cmd VkResult vkGetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+@@ -4747,7 +4702,7 @@ cmd VkResult vkGetSwapchainImagesKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ cmd VkResult vkAcquireNextImageKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+@@ -4764,7 +4719,7 @@ cmd VkResult vkAcquireNextImageKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_swapchain")
++@extension("VK_KHR_swapchain")
+ cmd VkResult vkQueuePresentKHR(
+ VkQueue queue,
+ VkPresentInfoKHR* pPresentInfo) {
+@@ -4776,7 +4731,7 @@ cmd VkResult vkQueuePresentKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ cmd VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ u32* pPropertyCount,
+@@ -4785,7 +4740,7 @@ cmd VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ cmd VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ u32* pPropertyCount,
+@@ -4794,7 +4749,7 @@ cmd VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ cmd VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
+ VkPhysicalDevice physicalDevice,
+ u32* pPropertyCount,
+@@ -4803,7 +4758,7 @@ cmd VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ cmd VkResult vkGetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+@@ -4813,7 +4768,7 @@ cmd VkResult vkGetDisplayModePropertiesKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ cmd VkResult vkCreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+@@ -4823,7 +4778,7 @@ cmd VkResult vkCreateDisplayModeKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ cmd VkResult vkGetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayModeCreateInfoKHR mode,
+@@ -4833,7 +4788,7 @@ cmd VkResult vkGetDisplayPlaneCapabilitiesKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_display")
++@extension("VK_KHR_display")
+ cmd VkResult vkCreateDisplayPlaneSurfaceKHR(
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+@@ -4841,7 +4796,7 @@ cmd VkResult vkCreateDisplayPlaneSurfaceKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_xlib_surface")
++@extension("VK_KHR_xlib_surface")
+ cmd VkResult vkCreateXlibSurfaceKHR(
+ VkInstance instance,
+ platform.Display* dpy,
+@@ -4851,7 +4806,7 @@ cmd VkResult vkCreateXlibSurfaceKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_xlib_surface")
++@extension("VK_KHR_xlib_surface")
+ cmd VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ u32 queueFamilyIndex,
+@@ -4861,7 +4816,7 @@ cmd VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_xcb_surface")
++@extension("VK_KHR_xcb_surface")
+ cmd VkResult vkCreateXCBSurfaceKHR(
+ VkInstance instance,
+ platform.xcb_connection_t* connection,
+@@ -4871,7 +4826,7 @@ cmd VkResult vkCreateXCBSurfaceKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_xlib_surface")
++@extension("VK_KHR_xlib_surface")
+ cmd VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ u32 queueFamilyIndex,
+@@ -4881,7 +4836,7 @@ cmd VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_wayland_surface")
++@extension("VK_KHR_wayland_surface")
+ cmd VkResult vkCreateWaylandSurfaceKHR(
+ VkInstance instance,
+ platform.wl_display* display,
+@@ -4891,7 +4846,7 @@ cmd VkResult vkCreateWaylandSurfaceKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_wayland_surface")
++@extension("VK_KHR_wayland_surface")
+ cmd VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ u32 queueFamilyIndex,
+@@ -4900,7 +4855,7 @@ cmd VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_mir_surface")
++@extension("VK_KHR_mir_surface")
+ cmd VkResult vkCreateMirSurfaceKHR(
+ VkInstance instance,
+ platform.MirConnection* connection,
+@@ -4910,7 +4865,7 @@ cmd VkResult vkCreateMirSurfaceKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_mir_surface")
++@extension("VK_KHR_mir_surface")
+ cmd VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ u32 queueFamilyIndex,
+@@ -4919,7 +4874,7 @@ cmd VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_android_surface")
++@extension("VK_KHR_android_surface")
+ cmd VkResult vkCreateAndroidSurfaceKHR(
+ VkInstance instance,
+ platform.ANativeWindow* window
+@@ -4928,7 +4883,7 @@ cmd VkResult vkCreateAndroidSurfaceKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_win32_surface")
++@extension("VK_KHR_win32_surface")
+ cmd VkResult vkCreateWin32SurfaceKHR(
+ VkInstance instance,
+ platform.HINSTANCE hinstance,
+@@ -4938,7 +4893,7 @@ cmd VkResult vkCreateWin32SurfaceKHR(
+ return ?
+ }
+
+-@extension("VK_EXT_KHR_win32_surface")
++@extension("VK_KHR_win32_surface")
+ cmd VkResult vkGetPhysicalDeviceWin32PresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ u32 queueFamilyIndex) {
+@@ -4975,7 +4930,6 @@ StateObject State
+ map!(VkImage, ref!ImageObject) Images
+ map!(VkImageView, ref!ImageViewObject) ImageViews
+ map!(VkShaderModule, ref!ShaderModuleObject) ShaderModules
+- map!(VkShader, ref!ShaderObject) Shaders
+ map!(VkPipeline, ref!PipelineObject) Pipelines
+ map!(VkPipelineLayout, ref!PipelineLayoutObject) PipelineLayouts
+ map!(VkSampler, ref!SamplerObject) Samplers
+@@ -5168,11 +5122,6 @@ macro ref!ImageViewObject GetImageView(VkImageView imageView) {
+ return State.ImageViews[imageView]
+ }
+
+-macro ref!ShaderObject GetShader(VkShader shader) {
+- assert(shader in State.Shaders)
+- return State.Shaders[shader]
+-}
+-
+ macro ref!ShaderModuleObject GetShaderModule(VkShaderModule shaderModule) {
+ assert(shaderModule in State.ShaderModules)
+ return State.ShaderModules[shaderModule]
+diff --git a/vulkan/include/vulkan/vk_android_native_buffer.h b/vulkan/include/vulkan/vk_android_native_buffer.h
+new file mode 100644
+index 0000000..f1f2676
+--- /dev/null
++++ b/vulkan/include/vulkan/vk_android_native_buffer.h
+@@ -0,0 +1,93 @@
++/*
++ * Copyright 2015 The Android Open Source Project
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ * http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#ifndef __VK_ANDROID_NATIVE_BUFFER_H__
++#define __VK_ANDROID_NATIVE_BUFFER_H__
++
++#include <vulkan/vulkan.h>
++#include <system/window.h>
++
++// TODO(jessehall): Get a real extension number officially assigned.
++#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER 1024
++#define VK_ANDROID_NATIVE_BUFFER_REVISION 1
++#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME "VK_ANDROID_native_buffer"
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++// See https://gitlab.khronos.org/vulkan/vulkan/blob/master/doc/proposals/proposed/NVIDIA/VulkanRegistryProposal.txt
++// and Khronos bug 14154 for explanation of these magic numbers.
++#define VK_ANDROID_NATIVE_BUFFER_ENUM(type,id) ((type)((int)0xc0000000 - VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER * -1024 + (id)))
++#define VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 0)
++
++typedef struct {
++ VkStructureType sType; // must be VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID
++ const void* pNext;
++
++ // Buffer handle and stride returned from gralloc alloc()
++ buffer_handle_t handle;
++ int stride;
++
++ // Gralloc format and usage requested when the buffer was allocated.
++ int format;
++ int usage;
++} VkNativeBufferANDROID;
++
++typedef VkResult (VKAPI *PFN_vkGetSwapchainGrallocUsageANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
++typedef VkResult (VKAPI *PFN_vkAcquireImageANDROID)(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore);
++typedef VkResult (VKAPI *PFN_vkQueueSignalReleaseImageANDROID)(VkQueue queue, VkImage image, int* pNativeFenceFd);
++// -- DEPRECATED --
++typedef VkResult (VKAPI *PFN_vkImportNativeFenceANDROID)(VkDevice device, VkSemaphore semaphore, int nativeFenceFd);
++typedef VkResult (VKAPI *PFN_vkQueueSignalNativeFenceANDROID)(VkQueue queue, int* pNativeFenceFd);
++// ----------------
++
++#ifdef VK_PROTOTYPES
++VkResult VKAPI vkGetSwapchainGrallocUsageANDROID(
++ VkDevice device,
++ VkFormat format,
++ VkImageUsageFlags imageUsage,
++ int* grallocUsage
++);
++VkResult VKAPI vkAcquireImageANDROID(
++ VkDevice device,
++ VkImage image,
++ int nativeFenceFd,
++ VkSemaphore semaphore
++);
++VkResult VKAPI vkQueueSignalReleaseImageANDROID(
++ VkQueue queue,
++ VkImage image,
++ int* pNativeFenceFd
++);
++// -- DEPRECATED --
++VkResult VKAPI vkImportNativeFenceANDROID(
++ VkDevice device,
++ VkSemaphore semaphore,
++ int nativeFenceFd
++);
++VkResult VKAPI vkQueueSignalNativeFenceANDROID(
++ VkQueue queue,
++ int* pNativeFenceFd
++);
++// ----------------
++#endif
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif // __VK_ANDROID_NATIVE_BUFFER_H__
+diff --git a/vulkan/include/vulkan/vk_ext_android_native_buffer.h b/vulkan/include/vulkan/vk_ext_android_native_buffer.h
+deleted file mode 100644
+index f665164..0000000
+--- a/vulkan/include/vulkan/vk_ext_android_native_buffer.h
++++ /dev/null
+@@ -1,93 +0,0 @@
+-/*
+- * Copyright 2015 The Android Open Source Project
+- *
+- * Licensed under the Apache License, Version 2.0 (the "License");
+- * you may not use this file except in compliance with the License.
+- * You may obtain a copy of the License at
+- *
+- * http://www.apache.org/licenses/LICENSE-2.0
+- *
+- * Unless required by applicable law or agreed to in writing, software
+- * distributed under the License is distributed on an "AS IS" BASIS,
+- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+- * See the License for the specific language governing permissions and
+- * limitations under the License.
+- */
+-
+-#ifndef __VK_EXT_ANDROID_NATIVE_BUFFER_H__
+-#define __VK_EXT_ANDROID_NATIVE_BUFFER_H__
+-
+-#include <vulkan/vulkan.h>
+-#include <system/window.h>
+-
+-// TODO(jessehall): Get a real extension number officially assigned.
+-#define VK_EXT_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER 1024
+-#define VK_EXT_ANDROID_NATIVE_BUFFER_REVISION 1
+-#define VK_EXT_ANDROID_NATIVE_BUFFER_EXTENSION_NAME "VK_EXT_ANDROID_gralloc"
+-
+-#ifdef __cplusplus
+-extern "C" {
+-#endif
+-
+-// See https://gitlab.khronos.org/vulkan/vulkan/blob/master/doc/proposals/proposed/NVIDIA/VulkanRegistryProposal.txt
+-// and Khronos bug 14154 for explanation of these magic numbers.
+-#define VK_EXT_ANDROID_NATIVE_BUFFER_ENUM(type,id) ((type)((int)0xc0000000 - VK_EXT_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER * -1024 + (id)))
+-#define VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID VK_EXT_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 0)
+-
+-typedef struct {
+- VkStructureType sType; // must be VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID
+- const void* pNext;
+-
+- // Buffer handle and stride returned from gralloc alloc()
+- buffer_handle_t handle;
+- int stride;
+-
+- // Gralloc format and usage requested when the buffer was allocated.
+- int format;
+- int usage;
+-} VkNativeBufferANDROID;
+-
+-typedef VkResult (VKAPI *PFN_vkGetSwapchainGrallocUsageANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
+-typedef VkResult (VKAPI *PFN_vkAcquireImageANDROID)(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore);
+-typedef VkResult (VKAPI *PFN_vkQueueSignalReleaseImageANDROID)(VkQueue queue, VkImage image, int* pNativeFenceFd);
+-// -- DEPRECATED --
+-typedef VkResult (VKAPI *PFN_vkImportNativeFenceANDROID)(VkDevice device, VkSemaphore semaphore, int nativeFenceFd);
+-typedef VkResult (VKAPI *PFN_vkQueueSignalNativeFenceANDROID)(VkQueue queue, int* pNativeFenceFd);
+-// ----------------
+-
+-#ifdef VK_PROTOTYPES
+-VkResult VKAPI vkGetSwapchainGrallocUsageANDROID(
+- VkDevice device,
+- VkFormat format,
+- VkImageUsageFlags imageUsage,
+- int* grallocUsage
+-);
+-VkResult VKAPI vkAcquireImageANDROID(
+- VkDevice device,
+- VkImage image,
+- int nativeFenceFd,
+- VkSemaphore semaphore
+-);
+-VkResult VKAPI vkQueueSignalReleaseImageANDROID(
+- VkQueue queue,
+- VkImage image,
+- int* pNativeFenceFd
+-);
+-// -- DEPRECATED --
+-VkResult VKAPI vkImportNativeFenceANDROID(
+- VkDevice device,
+- VkSemaphore semaphore,
+- int nativeFenceFd
+-);
+-VkResult VKAPI vkQueueSignalNativeFenceANDROID(
+- VkQueue queue,
+- int* pNativeFenceFd
+-);
+-// ----------------
+-#endif
+-
+-#ifdef __cplusplus
+-}
+-#endif
+-
+-#endif // __VK_EXT_ANDROID_NATIVE_BUFFER_H__
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 60583c2..2e66e27 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,11 +41,11 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 198, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 200, 0)
+
+
+ #define VK_NULL_HANDLE 0
+-
++
+
+
+ #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
+@@ -56,7 +56,7 @@ extern "C" {
+ #else
+ #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
+ #endif
+-
++
+
+
+ typedef uint32_t VkFlags;
+@@ -79,7 +79,6 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
+-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShader)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
+@@ -108,7 +107,7 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
+ #define VK_MAX_DESCRIPTION_SIZE 256
+
+
+-typedef enum {
++typedef enum VkResult {
+ VK_SUCCESS = 0,
+ VK_NOT_READY = 1,
+ VK_TIMEOUT = 2,
+@@ -130,7 +129,7 @@ typedef enum {
+ VK_RESULT_MAX_ENUM = 0x7FFFFFFF
+ } VkResult;
+
+-typedef enum {
++typedef enum VkStructureType {
+ VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
+@@ -148,57 +147,56 @@ typedef enum {
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
+ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
+ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
+- VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 17,
+- VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 18,
+- VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19,
+- VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 20,
+- VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 21,
+- VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 22,
+- VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 23,
+- VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 24,
+- VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 25,
+- VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 26,
+- VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
+- VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 28,
+- VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 29,
+- VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 30,
+- VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 31,
+- VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 32,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 33,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 34,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 35,
+- VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 36,
+- VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 37,
+- VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 38,
+- VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 39,
+- VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 40,
+- VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 41,
+- VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
+- VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
+- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
+- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
+- VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
+- VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 47,
+- VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 48,
++ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
++ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
++ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
++ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
++ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
++ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
++ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
++ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
++ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
++ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
++ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
++ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
++ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
++ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
++ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 34,
++ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
++ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
++ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
++ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
++ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
++ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 40,
++ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 41,
++ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 42,
++ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43,
++ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44,
++ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45,
++ VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 46,
++ VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 47,
+ VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+ VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO,
+ VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+ VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkStructureType;
+
+-typedef enum {
+- VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION = 0,
++typedef enum VkSystemAllocationScope {
++ VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
+ VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
+ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
+- VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION,
++ VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
+ VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
+- VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION + 1),
++ VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
+ VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
+ } VkSystemAllocationScope;
+
+-typedef enum {
++typedef enum VkInternalAllocationType {
+ VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
+ VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
+ VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
+@@ -206,7 +204,7 @@ typedef enum {
+ VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkInternalAllocationType;
+
+-typedef enum {
++typedef enum VkFormat {
+ VK_FORMAT_UNDEFINED = 0,
+ VK_FORMAT_R4G4_UNORM = 1,
+ VK_FORMAT_R4G4_USCALED = 2,
+@@ -387,7 +385,7 @@ typedef enum {
+ VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
+ } VkFormat;
+
+-typedef enum {
++typedef enum VkImageType {
+ VK_IMAGE_TYPE_1D = 0,
+ VK_IMAGE_TYPE_2D = 1,
+ VK_IMAGE_TYPE_3D = 2,
+@@ -397,7 +395,7 @@ typedef enum {
+ VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkImageType;
+
+-typedef enum {
++typedef enum VkImageTiling {
+ VK_IMAGE_TILING_OPTIMAL = 0,
+ VK_IMAGE_TILING_LINEAR = 1,
+ VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
+@@ -406,7 +404,7 @@ typedef enum {
+ VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
+ } VkImageTiling;
+
+-typedef enum {
++typedef enum VkPhysicalDeviceType {
+ VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
+ VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
+ VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
+@@ -418,7 +416,7 @@ typedef enum {
+ VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkPhysicalDeviceType;
+
+-typedef enum {
++typedef enum VkQueryType {
+ VK_QUERY_TYPE_OCCLUSION = 0,
+ VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
+ VK_QUERY_TYPE_TIMESTAMP = 2,
+@@ -428,7 +426,7 @@ typedef enum {
+ VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkQueryType;
+
+-typedef enum {
++typedef enum VkSharingMode {
+ VK_SHARING_MODE_EXCLUSIVE = 0,
+ VK_SHARING_MODE_CONCURRENT = 1,
+ VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
+@@ -437,7 +435,7 @@ typedef enum {
+ VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkSharingMode;
+
+-typedef enum {
++typedef enum VkImageLayout {
+ VK_IMAGE_LAYOUT_UNDEFINED = 0,
+ VK_IMAGE_LAYOUT_GENERAL = 1,
+ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
+@@ -453,7 +451,7 @@ typedef enum {
+ VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
+ } VkImageLayout;
+
+-typedef enum {
++typedef enum VkImageViewType {
+ VK_IMAGE_VIEW_TYPE_1D = 0,
+ VK_IMAGE_VIEW_TYPE_2D = 1,
+ VK_IMAGE_VIEW_TYPE_3D = 2,
+@@ -467,7 +465,7 @@ typedef enum {
+ VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkImageViewType;
+
+-typedef enum {
++typedef enum VkComponentSwizzle {
+ VK_COMPONENT_SWIZZLE_IDENTITY = 0,
+ VK_COMPONENT_SWIZZLE_ZERO = 1,
+ VK_COMPONENT_SWIZZLE_ONE = 2,
+@@ -481,7 +479,7 @@ typedef enum {
+ VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
+ } VkComponentSwizzle;
+
+-typedef enum {
++typedef enum VkVertexInputRate {
+ VK_VERTEX_INPUT_RATE_VERTEX = 0,
+ VK_VERTEX_INPUT_RATE_INSTANCE = 1,
+ VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
+@@ -490,7 +488,7 @@ typedef enum {
+ VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
+ } VkVertexInputRate;
+
+-typedef enum {
++typedef enum VkPrimitiveTopology {
+ VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
+ VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
+ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
+@@ -508,7 +506,7 @@ typedef enum {
+ VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
+ } VkPrimitiveTopology;
+
+-typedef enum {
++typedef enum VkPolygonMode {
+ VK_POLYGON_MODE_FILL = 0,
+ VK_POLYGON_MODE_LINE = 1,
+ VK_POLYGON_MODE_POINT = 2,
+@@ -518,7 +516,7 @@ typedef enum {
+ VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkPolygonMode;
+
+-typedef enum {
++typedef enum VkFrontFace {
+ VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
+ VK_FRONT_FACE_CLOCKWISE = 1,
+ VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
+@@ -527,7 +525,7 @@ typedef enum {
+ VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
+ } VkFrontFace;
+
+-typedef enum {
++typedef enum VkCompareOp {
+ VK_COMPARE_OP_NEVER = 0,
+ VK_COMPARE_OP_LESS = 1,
+ VK_COMPARE_OP_EQUAL = 2,
+@@ -542,7 +540,7 @@ typedef enum {
+ VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkCompareOp;
+
+-typedef enum {
++typedef enum VkStencilOp {
+ VK_STENCIL_OP_KEEP = 0,
+ VK_STENCIL_OP_ZERO = 1,
+ VK_STENCIL_OP_REPLACE = 2,
+@@ -557,7 +555,7 @@ typedef enum {
+ VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkStencilOp;
+
+-typedef enum {
++typedef enum VkLogicOp {
+ VK_LOGIC_OP_CLEAR = 0,
+ VK_LOGIC_OP_AND = 1,
+ VK_LOGIC_OP_AND_REVERSE = 2,
+@@ -580,7 +578,7 @@ typedef enum {
+ VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkLogicOp;
+
+-typedef enum {
++typedef enum VkBlendFactor {
+ VK_BLEND_FACTOR_ZERO = 0,
+ VK_BLEND_FACTOR_ONE = 1,
+ VK_BLEND_FACTOR_SRC_COLOR = 2,
+@@ -606,7 +604,7 @@ typedef enum {
+ VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
+ } VkBlendFactor;
+
+-typedef enum {
++typedef enum VkBlendOp {
+ VK_BLEND_OP_ADD = 0,
+ VK_BLEND_OP_SUBTRACT = 1,
+ VK_BLEND_OP_REVERSE_SUBTRACT = 2,
+@@ -618,7 +616,7 @@ typedef enum {
+ VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkBlendOp;
+
+-typedef enum {
++typedef enum VkDynamicState {
+ VK_DYNAMIC_STATE_VIEWPORT = 0,
+ VK_DYNAMIC_STATE_SCISSOR = 1,
+ VK_DYNAMIC_STATE_LINE_WIDTH = 2,
+@@ -634,7 +632,7 @@ typedef enum {
+ VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
+ } VkDynamicState;
+
+-typedef enum {
++typedef enum VkFilter {
+ VK_FILTER_NEAREST = 0,
+ VK_FILTER_LINEAR = 1,
+ VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
+@@ -643,7 +641,7 @@ typedef enum {
+ VK_FILTER_MAX_ENUM = 0x7FFFFFFF
+ } VkFilter;
+
+-typedef enum {
++typedef enum VkSamplerMipmapMode {
+ VK_SAMPLER_MIPMAP_MODE_BASE = 0,
+ VK_SAMPLER_MIPMAP_MODE_NEAREST = 1,
+ VK_SAMPLER_MIPMAP_MODE_LINEAR = 2,
+@@ -653,7 +651,7 @@ typedef enum {
+ VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkSamplerMipmapMode;
+
+-typedef enum {
++typedef enum VkSamplerAddressMode {
+ VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
+ VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
+ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
+@@ -665,7 +663,7 @@ typedef enum {
+ VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
+ } VkSamplerAddressMode;
+
+-typedef enum {
++typedef enum VkBorderColor {
+ VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
+ VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
+ VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
+@@ -678,7 +676,7 @@ typedef enum {
+ VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
+ } VkBorderColor;
+
+-typedef enum {
++typedef enum VkDescriptorType {
+ VK_DESCRIPTOR_TYPE_SAMPLER = 0,
+ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
+ VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
+@@ -696,7 +694,7 @@ typedef enum {
+ VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkDescriptorType;
+
+-typedef enum {
++typedef enum VkAttachmentLoadOp {
+ VK_ATTACHMENT_LOAD_OP_LOAD = 0,
+ VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
+@@ -706,7 +704,7 @@ typedef enum {
+ VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkAttachmentLoadOp;
+
+-typedef enum {
++typedef enum VkAttachmentStoreOp {
+ VK_ATTACHMENT_STORE_OP_STORE = 0,
+ VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
+ VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
+@@ -715,7 +713,7 @@ typedef enum {
+ VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
+ } VkAttachmentStoreOp;
+
+-typedef enum {
++typedef enum VkPipelineBindPoint {
+ VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
+ VK_PIPELINE_BIND_POINT_COMPUTE = 1,
+ VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
+@@ -724,7 +722,7 @@ typedef enum {
+ VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
+ } VkPipelineBindPoint;
+
+-typedef enum {
++typedef enum VkCommandBufferLevel {
+ VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
+ VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
+ VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+@@ -733,7 +731,7 @@ typedef enum {
+ VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
+ } VkCommandBufferLevel;
+
+-typedef enum {
++typedef enum VkIndexType {
+ VK_INDEX_TYPE_UINT16 = 0,
+ VK_INDEX_TYPE_UINT32 = 1,
+ VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
+@@ -742,7 +740,7 @@ typedef enum {
+ VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkIndexType;
+
+-typedef enum {
++typedef enum VkSubpassContents {
+ VK_SUBPASS_CONTENTS_INLINE = 0,
+ VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
+ VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
+@@ -753,7 +751,7 @@ typedef enum {
+
+ typedef VkFlags VkInstanceCreateFlags;
+
+-typedef enum {
++typedef enum VkFormatFeatureFlagBits {
+ VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
+ VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
+ VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
+@@ -769,7 +767,7 @@ typedef enum {
+ } VkFormatFeatureFlagBits;
+ typedef VkFlags VkFormatFeatureFlags;
+
+-typedef enum {
++typedef enum VkImageUsageFlagBits {
+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+ VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
+ VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
+@@ -781,7 +779,7 @@ typedef enum {
+ } VkImageUsageFlagBits;
+ typedef VkFlags VkImageUsageFlags;
+
+-typedef enum {
++typedef enum VkImageCreateFlagBits {
+ VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
+ VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
+ VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
+@@ -790,7 +788,7 @@ typedef enum {
+ } VkImageCreateFlagBits;
+ typedef VkFlags VkImageCreateFlags;
+
+-typedef enum {
++typedef enum VkSampleCountFlagBits {
+ VK_SAMPLE_COUNT_1_BIT = 0x00000001,
+ VK_SAMPLE_COUNT_2_BIT = 0x00000002,
+ VK_SAMPLE_COUNT_4_BIT = 0x00000004,
+@@ -801,7 +799,7 @@ typedef enum {
+ } VkSampleCountFlagBits;
+ typedef VkFlags VkSampleCountFlags;
+
+-typedef enum {
++typedef enum VkQueueFlagBits {
+ VK_QUEUE_GRAPHICS_BIT = 0x00000001,
+ VK_QUEUE_COMPUTE_BIT = 0x00000002,
+ VK_QUEUE_TRANSFER_BIT = 0x00000004,
+@@ -809,7 +807,7 @@ typedef enum {
+ } VkQueueFlagBits;
+ typedef VkFlags VkQueueFlags;
+
+-typedef enum {
++typedef enum VkMemoryPropertyFlagBits {
+ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
+ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
+ VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
+@@ -818,7 +816,7 @@ typedef enum {
+ } VkMemoryPropertyFlagBits;
+ typedef VkFlags VkMemoryPropertyFlags;
+
+-typedef enum {
++typedef enum VkMemoryHeapFlagBits {
+ VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
+ } VkMemoryHeapFlagBits;
+ typedef VkFlags VkMemoryHeapFlags;
+@@ -826,14 +824,15 @@ typedef VkFlags VkDeviceCreateFlags;
+ typedef VkFlags VkDeviceQueueCreateFlags;
+ typedef VkFlags VkMemoryMapFlags;
+
+-typedef enum {
++typedef enum VkImageAspectFlagBits {
+ VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
+ VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
+ VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
+ VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
+ } VkImageAspectFlagBits;
++typedef VkFlags VkImageAspectFlags;
+
+-typedef enum {
++typedef enum VkSparseImageFormatFlagBits {
+ VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
+ VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
+ VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
+@@ -841,7 +840,7 @@ typedef enum {
+ typedef VkFlags VkSparseImageFormatFlags;
+ typedef VkFlags VkSparseMemoryBindFlags;
+
+-typedef enum {
++typedef enum VkFenceCreateFlagBits {
+ VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
+ } VkFenceCreateFlagBits;
+ typedef VkFlags VkFenceCreateFlags;
+@@ -849,7 +848,7 @@ typedef VkFlags VkSemaphoreCreateFlags;
+ typedef VkFlags VkEventCreateFlags;
+ typedef VkFlags VkQueryPoolCreateFlags;
+
+-typedef enum {
++typedef enum VkQueryPipelineStatisticFlagBits {
+ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
+ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
+ VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
+@@ -864,7 +863,7 @@ typedef enum {
+ } VkQueryPipelineStatisticFlagBits;
+ typedef VkFlags VkQueryPipelineStatisticFlags;
+
+-typedef enum {
++typedef enum VkQueryResultFlagBits {
+ VK_QUERY_RESULT_DEFAULT = 0,
+ VK_QUERY_RESULT_64_BIT = 0x00000001,
+ VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
+@@ -873,14 +872,14 @@ typedef enum {
+ } VkQueryResultFlagBits;
+ typedef VkFlags VkQueryResultFlags;
+
+-typedef enum {
++typedef enum VkBufferCreateFlagBits {
+ VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
+ VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
+ VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
+ } VkBufferCreateFlagBits;
+ typedef VkFlags VkBufferCreateFlags;
+
+-typedef enum {
++typedef enum VkBufferUsageFlagBits {
+ VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+ VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
+ VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
+@@ -894,11 +893,18 @@ typedef enum {
+ typedef VkFlags VkBufferUsageFlags;
+ typedef VkFlags VkBufferViewCreateFlags;
+ typedef VkFlags VkImageViewCreateFlags;
+-typedef VkFlags VkImageAspectFlags;
+ typedef VkFlags VkShaderModuleCreateFlags;
+-typedef VkFlags VkShaderCreateFlags;
++typedef VkFlags VkPipelineCacheCreateFlags;
+
+-typedef enum {
++typedef enum VkPipelineCreateFlagBits {
++ VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
++ VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
++ VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
++} VkPipelineCreateFlagBits;
++typedef VkFlags VkPipelineCreateFlags;
++typedef VkFlags VkPipelineShaderStageCreateFlags;
++
++typedef enum VkShaderStageFlagBits {
+ VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
+ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
+ VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
+@@ -908,22 +914,13 @@ typedef enum {
+ VK_SHADER_STAGE_ALL_GRAPHICS = 0x1F,
+ VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+ } VkShaderStageFlagBits;
+-typedef VkFlags VkPipelineCacheCreateFlags;
+-
+-typedef enum {
+- VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
+- VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
+- VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
+-} VkPipelineCreateFlagBits;
+-typedef VkFlags VkPipelineCreateFlags;
+-typedef VkFlags VkPipelineShaderStageCreateFlags;
+ typedef VkFlags VkPipelineVertexInputStateCreateFlags;
+ typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
+ typedef VkFlags VkPipelineTesselationStateCreateFlags;
+ typedef VkFlags VkPipelineViewportStateCreateFlags;
+ typedef VkFlags VkPipelineRasterizationStateCreateFlags;
+
+-typedef enum {
++typedef enum VkCullModeFlagBits {
+ VK_CULL_MODE_NONE = 0,
+ VK_CULL_MODE_FRONT_BIT = 0x00000001,
+ VK_CULL_MODE_BACK_BIT = 0x00000002,
+@@ -934,7 +931,7 @@ typedef VkFlags VkPipelineMultisampleStateCreateFlags;
+ typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
+ typedef VkFlags VkPipelineColorBlendStateCreateFlags;
+
+-typedef enum {
++typedef enum VkColorComponentFlagBits {
+ VK_COLOR_COMPONENT_R_BIT = 0x00000001,
+ VK_COLOR_COMPONENT_G_BIT = 0x00000002,
+ VK_COLOR_COMPONENT_B_BIT = 0x00000004,
+@@ -947,7 +944,7 @@ typedef VkFlags VkShaderStageFlags;
+ typedef VkFlags VkSamplerCreateFlags;
+ typedef VkFlags VkDescriptorSetLayoutCreateFlags;
+
+-typedef enum {
++typedef enum VkDescriptorPoolCreateFlagBits {
+ VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
+ } VkDescriptorPoolCreateFlagBits;
+ typedef VkFlags VkDescriptorPoolCreateFlags;
+@@ -955,13 +952,13 @@ typedef VkFlags VkDescriptorPoolResetFlags;
+ typedef VkFlags VkFramebufferCreateFlags;
+ typedef VkFlags VkRenderPassCreateFlags;
+
+-typedef enum {
++typedef enum VkAttachmentDescriptionFlagBits {
+ VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
+ } VkAttachmentDescriptionFlagBits;
+ typedef VkFlags VkAttachmentDescriptionFlags;
+ typedef VkFlags VkSubpassDescriptionFlags;
+
+-typedef enum {
++typedef enum VkPipelineStageFlagBits {
+ VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
+ VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
+ VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
+@@ -981,58 +978,56 @@ typedef enum {
+ } VkPipelineStageFlagBits;
+ typedef VkFlags VkPipelineStageFlags;
+
+-typedef enum {
+- VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001,
+- VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002,
+- VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004,
+- VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008,
+- VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010,
+-} VkMemoryOutputFlagBits;
+-typedef VkFlags VkMemoryOutputFlags;
+-
+-typedef enum {
+- VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001,
+- VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002,
+- VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004,
+- VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008,
+- VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010,
+- VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020,
+- VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040,
+- VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080,
+- VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100,
+- VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200,
+-} VkMemoryInputFlagBits;
+-typedef VkFlags VkMemoryInputFlags;
+-
+-typedef enum {
++typedef enum VkAccessFlagBits {
++ VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
++ VK_ACCESS_INDEX_READ_BIT = 0x00000002,
++ VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
++ VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
++ VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
++ VK_ACCESS_SHADER_READ_BIT = 0x00000020,
++ VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
++ VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
++ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
++ VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
++ VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
++ VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
++ VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
++ VK_ACCESS_HOST_READ_BIT = 0x00002000,
++ VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
++ VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
++ VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
++} VkAccessFlagBits;
++typedef VkFlags VkAccessFlags;
++
++typedef enum VkDependencyFlagBits {
+ VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
+ } VkDependencyFlagBits;
+ typedef VkFlags VkDependencyFlags;
+
+-typedef enum {
++typedef enum VkCommandPoolCreateFlagBits {
+ VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
+ VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
+ } VkCommandPoolCreateFlagBits;
+ typedef VkFlags VkCommandPoolCreateFlags;
+
+-typedef enum {
++typedef enum VkCommandPoolResetFlagBits {
+ VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+ } VkCommandPoolResetFlagBits;
+ typedef VkFlags VkCommandPoolResetFlags;
+
+-typedef enum {
++typedef enum VkCommandBufferUsageFlagBits {
+ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
+ VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
+ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
+ } VkCommandBufferUsageFlagBits;
+ typedef VkFlags VkCommandBufferUsageFlags;
+
+-typedef enum {
++typedef enum VkCommandBufferResetFlagBits {
+ VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+ } VkCommandBufferResetFlagBits;
+ typedef VkFlags VkCommandBufferResetFlags;
+
+-typedef enum {
++typedef enum VkStencilFaceFlagBits {
+ VK_STENCIL_FACE_NONE = 0,
+ VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
+ VK_STENCIL_FACE_BACK_BIT = 0x00000002,
+@@ -1040,43 +1035,43 @@ typedef enum {
+ } VkStencilFaceFlagBits;
+ typedef VkFlags VkStencilFaceFlags;
+
+-typedef enum {
++typedef enum VkQueryControlFlagBits {
+ VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
+ } VkQueryControlFlagBits;
+ typedef VkFlags VkQueryControlFlags;
+
+ typedef void* (VKAPI *PFN_vkAllocationFunction)(
+- void* pUserData,
+- size_t size,
+- size_t alignment,
+- VkSystemAllocationScope allocationScope);
++ void* pUserData,
++ size_t size,
++ size_t alignment,
++ VkSystemAllocationScope allocationScope);
+
+ typedef void* (VKAPI *PFN_vkReallocationFunction)(
+- void* pUserData,
+- void* pOriginal,
+- size_t size,
+- size_t alignment,
+- VkSystemAllocationScope allocationScope);
++ void* pUserData,
++ void* pOriginal,
++ size_t size,
++ size_t alignment,
++ VkSystemAllocationScope allocationScope);
+
+ typedef void (VKAPI *PFN_vkFreeFunction)(
+- void* pUserData,
+- void* pMemory);
++ void* pUserData,
++ void* pMemory);
+
+ typedef void (VKAPI *PFN_vkInternalAllocationNotification)(
+- void* pUserData,
+- size_t size,
+- VkInternalAllocationType allocationType,
+- VkSystemAllocationScope allocationScope);
++ void* pUserData,
++ size_t size,
++ VkInternalAllocationType allocationType,
++ VkSystemAllocationScope allocationScope);
+
+ typedef void (VKAPI *PFN_vkInternalFreeNotification)(
+- void* pUserData,
+- size_t size,
+- VkInternalAllocationType allocationType,
+- VkSystemAllocationScope allocationScope);
++ void* pUserData,
++ size_t size,
++ VkInternalAllocationType allocationType,
++ VkSystemAllocationScope allocationScope);
+
+ typedef void (VKAPI *PFN_vkVoidFunction)(void);
+
+-typedef struct {
++typedef struct VkApplicationInfo {
+ VkStructureType sType;
+ const void* pNext;
+ const char* pApplicationName;
+@@ -1086,7 +1081,7 @@ typedef struct {
+ uint32_t apiVersion;
+ } VkApplicationInfo;
+
+-typedef struct {
++typedef struct VkInstanceCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkInstanceCreateFlags flags;
+@@ -1097,7 +1092,7 @@ typedef struct {
+ const char*const* ppEnabledExtensionNames;
+ } VkInstanceCreateInfo;
+
+-typedef struct {
++typedef struct VkAllocationCallbacks {
+ void* pUserData;
+ PFN_vkAllocationFunction pfnAllocation;
+ PFN_vkReallocationFunction pfnReallocation;
+@@ -1106,7 +1101,7 @@ typedef struct {
+ PFN_vkInternalFreeNotification pfnInternalFree;
+ } VkAllocationCallbacks;
+
+-typedef struct {
++typedef struct VkPhysicalDeviceFeatures {
+ VkBool32 robustBufferAccess;
+ VkBool32 fullDrawIndexUint32;
+ VkBool32 imageCubeArray;
+@@ -1162,19 +1157,19 @@ typedef struct {
+ VkBool32 variableMultisampleRate;
+ } VkPhysicalDeviceFeatures;
+
+-typedef struct {
++typedef struct VkFormatProperties {
+ VkFormatFeatureFlags linearTilingFeatures;
+ VkFormatFeatureFlags optimalTilingFeatures;
+ VkFormatFeatureFlags bufferFeatures;
+ } VkFormatProperties;
+
+-typedef struct {
++typedef struct VkExtent3D {
+ int32_t width;
+ int32_t height;
+ int32_t depth;
+ } VkExtent3D;
+
+-typedef struct {
++typedef struct VkImageFormatProperties {
+ VkExtent3D maxExtent;
+ uint32_t maxMipLevels;
+ uint32_t maxArrayLayers;
+@@ -1182,7 +1177,7 @@ typedef struct {
+ VkDeviceSize maxResourceSize;
+ } VkImageFormatProperties;
+
+-typedef struct {
++typedef struct VkPhysicalDeviceLimits {
+ uint32_t maxImageDimension1D;
+ uint32_t maxImageDimension2D;
+ uint32_t maxImageDimension3D;
+@@ -1284,7 +1279,7 @@ typedef struct {
+ VkDeviceSize optimalBufferCopyRowPitchAlignment;
+ } VkPhysicalDeviceLimits;
+
+-typedef struct {
++typedef struct VkPhysicalDeviceSparseProperties {
+ VkBool32 residencyStandard2DBlockShape;
+ VkBool32 residencyStandard2DMultisampleBlockShape;
+ VkBool32 residencyStandard3DBlockShape;
+@@ -1292,7 +1287,7 @@ typedef struct {
+ VkBool32 residencyNonResidentStrict;
+ } VkPhysicalDeviceSparseProperties;
+
+-typedef struct {
++typedef struct VkPhysicalDeviceProperties {
+ uint32_t apiVersion;
+ uint32_t driverVersion;
+ uint32_t vendorID;
+@@ -1304,31 +1299,31 @@ typedef struct {
+ VkPhysicalDeviceSparseProperties sparseProperties;
+ } VkPhysicalDeviceProperties;
+
+-typedef struct {
++typedef struct VkQueueFamilyProperties {
+ VkQueueFlags queueFlags;
+ uint32_t queueCount;
+ uint32_t timestampValidBits;
+ VkExtent3D minImageTransferGranularity;
+ } VkQueueFamilyProperties;
+
+-typedef struct {
++typedef struct VkMemoryType {
+ VkMemoryPropertyFlags propertyFlags;
+ uint32_t heapIndex;
+ } VkMemoryType;
+
+-typedef struct {
++typedef struct VkMemoryHeap {
+ VkDeviceSize size;
+ VkMemoryHeapFlags flags;
+ } VkMemoryHeap;
+
+-typedef struct {
++typedef struct VkPhysicalDeviceMemoryProperties {
+ uint32_t memoryTypeCount;
+ VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
+ uint32_t memoryHeapCount;
+ VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
+ } VkPhysicalDeviceMemoryProperties;
+
+-typedef struct {
++typedef struct VkDeviceQueueCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceQueueCreateFlags flags;
+@@ -1337,7 +1332,7 @@ typedef struct {
+ const float* pQueuePriorities;
+ } VkDeviceQueueCreateInfo;
+
+-typedef struct {
++typedef struct VkDeviceCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceCreateFlags flags;
+@@ -1350,19 +1345,19 @@ typedef struct {
+ const VkPhysicalDeviceFeatures* pEnabledFeatures;
+ } VkDeviceCreateInfo;
+
+-typedef struct {
++typedef struct VkExtensionProperties {
+ char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
+ uint32_t specVersion;
+ } VkExtensionProperties;
+
+-typedef struct {
++typedef struct VkLayerProperties {
+ char layerName[VK_MAX_EXTENSION_NAME_SIZE];
+ uint32_t specVersion;
+ uint32_t implementationVersion;
+ char description[VK_MAX_DESCRIPTION_SIZE];
+ } VkLayerProperties;
+
+-typedef struct {
++typedef struct VkSubmitInfo {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t waitSemaphoreCount;
+@@ -1373,14 +1368,14 @@ typedef struct {
+ const VkSemaphore* pSignalSemaphores;
+ } VkSubmitInfo;
+
+-typedef struct {
++typedef struct VkMemoryAllocateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceSize allocationSize;
+ uint32_t memoryTypeIndex;
+ } VkMemoryAllocateInfo;
+
+-typedef struct {
++typedef struct VkMappedMemoryRange {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceMemory memory;
+@@ -1388,19 +1383,19 @@ typedef struct {
+ VkDeviceSize size;
+ } VkMappedMemoryRange;
+
+-typedef struct {
++typedef struct VkMemoryRequirements {
+ VkDeviceSize size;
+ VkDeviceSize alignment;
+ uint32_t memoryTypeBits;
+ } VkMemoryRequirements;
+
+-typedef struct {
+- VkImageAspectFlagBits aspect;
++typedef struct VkSparseImageFormatProperties {
++ VkImageAspectFlags aspectMask;
+ VkExtent3D imageGranularity;
+ VkSparseImageFormatFlags flags;
+ } VkSparseImageFormatProperties;
+
+-typedef struct {
++typedef struct VkSparseImageMemoryRequirements {
+ VkSparseImageFormatProperties formatProperties;
+ uint32_t imageMipTailStartLod;
+ VkDeviceSize imageMipTailSize;
+@@ -1408,7 +1403,7 @@ typedef struct {
+ VkDeviceSize imageMipTailStride;
+ } VkSparseImageMemoryRequirements;
+
+-typedef struct {
++typedef struct VkSparseMemoryBind {
+ VkDeviceSize resourceOffset;
+ VkDeviceSize size;
+ VkDeviceMemory memory;
+@@ -1416,31 +1411,31 @@ typedef struct {
+ VkSparseMemoryBindFlags flags;
+ } VkSparseMemoryBind;
+
+-typedef struct {
++typedef struct VkSparseBufferMemoryBindInfo {
+ VkBuffer buffer;
+ uint32_t bindCount;
+ const VkSparseMemoryBind* pBinds;
+ } VkSparseBufferMemoryBindInfo;
+
+-typedef struct {
++typedef struct VkSparseImageOpaqueMemoryBindInfo {
+ VkImage image;
+ uint32_t bindCount;
+ const VkSparseMemoryBind* pBinds;
+ } VkSparseImageOpaqueMemoryBindInfo;
+
+-typedef struct {
+- VkImageAspectFlagBits aspect;
++typedef struct VkImageSubresource {
++ VkImageAspectFlags aspectMask;
+ uint32_t mipLevel;
+ uint32_t arrayLayer;
+ } VkImageSubresource;
+
+-typedef struct {
++typedef struct VkOffset3D {
+ int32_t x;
+ int32_t y;
+ int32_t z;
+ } VkOffset3D;
+
+-typedef struct {
++typedef struct VkSparseImageMemoryBind {
+ VkImageSubresource subresource;
+ VkOffset3D offset;
+ VkExtent3D extent;
+@@ -1449,13 +1444,13 @@ typedef struct {
+ VkSparseMemoryBindFlags flags;
+ } VkSparseImageMemoryBind;
+
+-typedef struct {
++typedef struct VkSparseImageMemoryBindInfo {
+ VkImage image;
+ uint32_t bindCount;
+ const VkSparseImageMemoryBind* pBinds;
+ } VkSparseImageMemoryBindInfo;
+
+-typedef struct {
++typedef struct VkBindSparseInfo {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t waitSemaphoreCount;
+@@ -1470,25 +1465,25 @@ typedef struct {
+ const VkSemaphore* pSignalSemaphores;
+ } VkBindSparseInfo;
+
+-typedef struct {
++typedef struct VkFenceCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkFenceCreateFlags flags;
+ } VkFenceCreateInfo;
+
+-typedef struct {
++typedef struct VkSemaphoreCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkSemaphoreCreateFlags flags;
+ } VkSemaphoreCreateInfo;
+
+-typedef struct {
++typedef struct VkEventCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkEventCreateFlags flags;
+ } VkEventCreateInfo;
+
+-typedef struct {
++typedef struct VkQueryPoolCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkQueryPoolCreateFlags flags;
+@@ -1497,7 +1492,7 @@ typedef struct {
+ VkQueryPipelineStatisticFlags pipelineStatistics;
+ } VkQueryPoolCreateInfo;
+
+-typedef struct {
++typedef struct VkBufferCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkBufferCreateFlags flags;
+@@ -1508,7 +1503,7 @@ typedef struct {
+ const uint32_t* pQueueFamilyIndices;
+ } VkBufferCreateInfo;
+
+-typedef struct {
++typedef struct VkBufferViewCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkBufferViewCreateFlags flags;
+@@ -1518,7 +1513,7 @@ typedef struct {
+ VkDeviceSize range;
+ } VkBufferViewCreateInfo;
+
+-typedef struct {
++typedef struct VkImageCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkImageCreateFlags flags;
+@@ -1536,21 +1531,21 @@ typedef struct {
+ VkImageLayout initialLayout;
+ } VkImageCreateInfo;
+
+-typedef struct {
++typedef struct VkSubresourceLayout {
+ VkDeviceSize offset;
+ VkDeviceSize size;
+ VkDeviceSize rowPitch;
+ VkDeviceSize depthPitch;
+ } VkSubresourceLayout;
+
+-typedef struct {
++typedef struct VkComponentMapping {
+ VkComponentSwizzle r;
+ VkComponentSwizzle g;
+ VkComponentSwizzle b;
+ VkComponentSwizzle a;
+ } VkComponentMapping;
+
+-typedef struct {
++typedef struct VkImageSubresourceRange {
+ VkImageAspectFlags aspectMask;
+ uint32_t baseMipLevel;
+ uint32_t levelCount;
+@@ -1558,7 +1553,7 @@ typedef struct {
+ uint32_t layerCount;
+ } VkImageSubresourceRange;
+
+-typedef struct {
++typedef struct VkImageViewCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkImageViewCreateFlags flags;
+@@ -1569,7 +1564,7 @@ typedef struct {
+ VkImageSubresourceRange subresourceRange;
+ } VkImageViewCreateInfo;
+
+-typedef struct {
++typedef struct VkShaderModuleCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkShaderModuleCreateFlags flags;
+@@ -1577,16 +1572,7 @@ typedef struct {
+ const uint32_t* pCode;
+ } VkShaderModuleCreateInfo;
+
+-typedef struct {
+- VkStructureType sType;
+- const void* pNext;
+- VkShaderCreateFlags flags;
+- VkShaderModule module;
+- const char* pName;
+- VkShaderStageFlagBits stage;
+-} VkShaderCreateInfo;
+-
+-typedef struct {
++typedef struct VkPipelineCacheCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineCacheCreateFlags flags;
+@@ -1594,41 +1580,43 @@ typedef struct {
+ const void* pInitialData;
+ } VkPipelineCacheCreateInfo;
+
+-typedef struct {
++typedef struct VkSpecializationMapEntry {
+ uint32_t constantID;
+ uint32_t offset;
+ size_t size;
+ } VkSpecializationMapEntry;
+
+-typedef struct {
++typedef struct VkSpecializationInfo {
+ uint32_t mapEntryCount;
+ const VkSpecializationMapEntry* pMapEntries;
+ size_t dataSize;
+ const void* pData;
+ } VkSpecializationInfo;
+
+-typedef struct {
++typedef struct VkPipelineShaderStageCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineShaderStageCreateFlags flags;
+- VkShader shader;
++ VkShaderStageFlagBits stage;
++ VkShaderModule module;
++ const char* pName;
+ const VkSpecializationInfo* pSpecializationInfo;
+ } VkPipelineShaderStageCreateInfo;
+
+-typedef struct {
++typedef struct VkVertexInputBindingDescription {
+ uint32_t binding;
+ uint32_t stride;
+ VkVertexInputRate inputRate;
+ } VkVertexInputBindingDescription;
+
+-typedef struct {
++typedef struct VkVertexInputAttributeDescription {
+ uint32_t location;
+ uint32_t binding;
+ VkFormat format;
+ uint32_t offset;
+ } VkVertexInputAttributeDescription;
+
+-typedef struct {
++typedef struct VkPipelineVertexInputStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineVertexInputStateCreateFlags flags;
+@@ -1638,7 +1626,7 @@ typedef struct {
+ const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
+ } VkPipelineVertexInputStateCreateInfo;
+
+-typedef struct {
++typedef struct VkPipelineInputAssemblyStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineInputAssemblyStateCreateFlags flags;
+@@ -1646,14 +1634,14 @@ typedef struct {
+ VkBool32 primitiveRestartEnable;
+ } VkPipelineInputAssemblyStateCreateInfo;
+
+-typedef struct {
++typedef struct VkPipelineTessellationStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineTesselationStateCreateFlags flags;
+ uint32_t patchControlPoints;
+ } VkPipelineTessellationStateCreateInfo;
+
+-typedef struct {
++typedef struct VkViewport {
+ float x;
+ float y;
+ float width;
+@@ -1662,22 +1650,22 @@ typedef struct {
+ float maxDepth;
+ } VkViewport;
+
+-typedef struct {
++typedef struct VkOffset2D {
+ int32_t x;
+ int32_t y;
+ } VkOffset2D;
+
+-typedef struct {
++typedef struct VkExtent2D {
+ int32_t width;
+ int32_t height;
+ } VkExtent2D;
+
+-typedef struct {
++typedef struct VkRect2D {
+ VkOffset2D offset;
+ VkExtent2D extent;
+ } VkRect2D;
+
+-typedef struct {
++typedef struct VkPipelineViewportStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineViewportStateCreateFlags flags;
+@@ -1687,7 +1675,7 @@ typedef struct {
+ const VkRect2D* pScissors;
+ } VkPipelineViewportStateCreateInfo;
+
+-typedef struct {
++typedef struct VkPipelineRasterizationStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineRasterizationStateCreateFlags flags;
+@@ -1703,7 +1691,7 @@ typedef struct {
+ float lineWidth;
+ } VkPipelineRasterizationStateCreateInfo;
+
+-typedef struct {
++typedef struct VkPipelineMultisampleStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineMultisampleStateCreateFlags flags;
+@@ -1715,7 +1703,7 @@ typedef struct {
+ VkBool32 alphaToOneEnable;
+ } VkPipelineMultisampleStateCreateInfo;
+
+-typedef struct {
++typedef struct VkStencilOpState {
+ VkStencilOp failOp;
+ VkStencilOp passOp;
+ VkStencilOp depthFailOp;
+@@ -1725,7 +1713,7 @@ typedef struct {
+ uint32_t reference;
+ } VkStencilOpState;
+
+-typedef struct {
++typedef struct VkPipelineDepthStencilStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineDepthStencilStateCreateFlags flags;
+@@ -1740,7 +1728,7 @@ typedef struct {
+ float maxDepthBounds;
+ } VkPipelineDepthStencilStateCreateInfo;
+
+-typedef struct {
++typedef struct VkPipelineColorBlendAttachmentState {
+ VkBool32 blendEnable;
+ VkBlendFactor srcColorBlendFactor;
+ VkBlendFactor dstColorBlendFactor;
+@@ -1751,7 +1739,7 @@ typedef struct {
+ VkColorComponentFlags colorWriteMask;
+ } VkPipelineColorBlendAttachmentState;
+
+-typedef struct {
++typedef struct VkPipelineColorBlendStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineColorBlendStateCreateFlags flags;
+@@ -1762,7 +1750,7 @@ typedef struct {
+ float blendConstants[4];
+ } VkPipelineColorBlendStateCreateInfo;
+
+-typedef struct {
++typedef struct VkPipelineDynamicStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineDynamicStateCreateFlags flags;
+@@ -1770,7 +1758,7 @@ typedef struct {
+ const VkDynamicState* pDynamicStates;
+ } VkPipelineDynamicStateCreateInfo;
+
+-typedef struct {
++typedef struct VkGraphicsPipelineCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineCreateFlags flags;
+@@ -1792,7 +1780,7 @@ typedef struct {
+ int32_t basePipelineIndex;
+ } VkGraphicsPipelineCreateInfo;
+
+-typedef struct {
++typedef struct VkComputePipelineCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineCreateFlags flags;
+@@ -1802,13 +1790,13 @@ typedef struct {
+ int32_t basePipelineIndex;
+ } VkComputePipelineCreateInfo;
+
+-typedef struct {
++typedef struct VkPushConstantRange {
+ VkShaderStageFlags stageFlags;
+ uint32_t offset;
+ uint32_t size;
+ } VkPushConstantRange;
+
+-typedef struct {
++typedef struct VkPipelineLayoutCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineLayoutCreateFlags flags;
+@@ -1818,7 +1806,7 @@ typedef struct {
+ const VkPushConstantRange* pPushConstantRanges;
+ } VkPipelineLayoutCreateInfo;
+
+-typedef struct {
++typedef struct VkSamplerCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkSamplerCreateFlags flags;
+@@ -1838,27 +1826,27 @@ typedef struct {
+ VkBool32 unnormalizedCoordinates;
+ } VkSamplerCreateInfo;
+
+-typedef struct {
++typedef struct VkDescriptorSetLayoutBinding {
+ VkDescriptorType descriptorType;
+ uint32_t arraySize;
+ VkShaderStageFlags stageFlags;
+ const VkSampler* pImmutableSamplers;
+ } VkDescriptorSetLayoutBinding;
+
+-typedef struct {
++typedef struct VkDescriptorSetLayoutCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorSetLayoutCreateFlags flags;
+ uint32_t bindingCount;
+- const VkDescriptorSetLayoutBinding* pBindings;
++ const VkDescriptorSetLayoutBinding* pBinding;
+ } VkDescriptorSetLayoutCreateInfo;
+
+-typedef struct {
++typedef struct VkDescriptorPoolSize {
+ VkDescriptorType type;
+ uint32_t descriptorCount;
+ } VkDescriptorPoolSize;
+
+-typedef struct {
++typedef struct VkDescriptorPoolCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorPoolCreateFlags flags;
+@@ -1867,7 +1855,7 @@ typedef struct {
+ const VkDescriptorPoolSize* pPoolSizes;
+ } VkDescriptorPoolCreateInfo;
+
+-typedef struct {
++typedef struct VkDescriptorSetAllocateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorPool descriptorPool;
+@@ -1875,19 +1863,19 @@ typedef struct {
+ const VkDescriptorSetLayout* pSetLayouts;
+ } VkDescriptorSetAllocateInfo;
+
+-typedef struct {
++typedef struct VkDescriptorImageInfo {
+ VkSampler sampler;
+ VkImageView imageView;
+ VkImageLayout imageLayout;
+ } VkDescriptorImageInfo;
+
+-typedef struct {
++typedef struct VkDescriptorBufferInfo {
+ VkBuffer buffer;
+ VkDeviceSize offset;
+ VkDeviceSize range;
+ } VkDescriptorBufferInfo;
+
+-typedef struct {
++typedef struct VkWriteDescriptorSet {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorSet dstSet;
+@@ -1900,7 +1888,7 @@ typedef struct {
+ const VkBufferView* pTexelBufferView;
+ } VkWriteDescriptorSet;
+
+-typedef struct {
++typedef struct VkCopyDescriptorSet {
+ VkStructureType sType;
+ const void* pNext;
+ VkDescriptorSet srcSet;
+@@ -1912,7 +1900,7 @@ typedef struct {
+ uint32_t descriptorCount;
+ } VkCopyDescriptorSet;
+
+-typedef struct {
++typedef struct VkFramebufferCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkFramebufferCreateFlags flags;
+@@ -1924,7 +1912,7 @@ typedef struct {
+ uint32_t layers;
+ } VkFramebufferCreateInfo;
+
+-typedef struct {
++typedef struct VkAttachmentDescription {
+ VkAttachmentDescriptionFlags flags;
+ VkFormat format;
+ uint32_t samples;
+@@ -1936,12 +1924,12 @@ typedef struct {
+ VkImageLayout finalLayout;
+ } VkAttachmentDescription;
+
+-typedef struct {
++typedef struct VkAttachmentReference {
+ uint32_t attachment;
+ VkImageLayout layout;
+ } VkAttachmentReference;
+
+-typedef struct {
++typedef struct VkSubpassDescription {
+ VkSubpassDescriptionFlags flags;
+ VkPipelineBindPoint pipelineBindPoint;
+ uint32_t inputAttachmentCount;
+@@ -1954,17 +1942,17 @@ typedef struct {
+ const VkAttachmentReference* pPreserveAttachments;
+ } VkSubpassDescription;
+
+-typedef struct {
++typedef struct VkSubpassDependency {
+ uint32_t srcSubpass;
+ uint32_t dstSubpass;
+ VkPipelineStageFlags srcStageMask;
+ VkPipelineStageFlags dstStageMask;
+- VkMemoryOutputFlags outputMask;
+- VkMemoryInputFlags inputMask;
++ VkAccessFlags srcAccessMask;
++ VkAccessFlags dstAccessMask;
+ VkDependencyFlags dependencyFlags;
+ } VkSubpassDependency;
+
+-typedef struct {
++typedef struct VkRenderPassCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkRenderPassCreateFlags flags;
+@@ -1976,14 +1964,14 @@ typedef struct {
+ const VkSubpassDependency* pDependencies;
+ } VkRenderPassCreateInfo;
+
+-typedef struct {
++typedef struct VkCommandPoolCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkCommandPoolCreateFlags flags;
+ uint32_t queueFamilyIndex;
+ } VkCommandPoolCreateInfo;
+
+-typedef struct {
++typedef struct VkCommandBufferAllocateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkCommandPool commandPool;
+@@ -1991,7 +1979,7 @@ typedef struct {
+ uint32_t bufferCount;
+ } VkCommandBufferAllocateInfo;
+
+-typedef struct {
++typedef struct VkCommandBufferBeginInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkCommandBufferUsageFlags flags;
+@@ -2000,20 +1988,20 @@ typedef struct {
+ VkFramebuffer framebuffer;
+ } VkCommandBufferBeginInfo;
+
+-typedef struct {
++typedef struct VkBufferCopy {
+ VkDeviceSize srcOffset;
+ VkDeviceSize dstOffset;
+ VkDeviceSize size;
+ } VkBufferCopy;
+
+-typedef struct {
++typedef struct VkImageSubresourceLayers {
+ VkImageAspectFlags aspectMask;
+ uint32_t mipLevel;
+ uint32_t baseArrayLayer;
+ uint32_t layerCount;
+ } VkImageSubresourceLayers;
+
+-typedef struct {
++typedef struct VkImageCopy {
+ VkImageSubresourceLayers srcSubresource;
+ VkOffset3D srcOffset;
+ VkImageSubresourceLayers dstSubresource;
+@@ -2021,7 +2009,7 @@ typedef struct {
+ VkExtent3D extent;
+ } VkImageCopy;
+
+-typedef struct {
++typedef struct VkImageBlit {
+ VkImageSubresourceLayers srcSubresource;
+ VkOffset3D srcOffset;
+ VkExtent3D srcExtent;
+@@ -2030,7 +2018,7 @@ typedef struct {
+ VkExtent3D dstExtent;
+ } VkImageBlit;
+
+-typedef struct {
++typedef struct VkBufferImageCopy {
+ VkDeviceSize bufferOffset;
+ uint32_t bufferRowLength;
+ uint32_t bufferImageHeight;
+@@ -2039,35 +2027,35 @@ typedef struct {
+ VkExtent3D imageExtent;
+ } VkBufferImageCopy;
+
+-typedef union {
++typedef union VkClearColorValue {
+ float float32[4];
+ int32_t int32[4];
+ uint32_t uint32[4];
+ } VkClearColorValue;
+
+-typedef struct {
++typedef struct VkClearDepthStencilValue {
+ float depth;
+ uint32_t stencil;
+ } VkClearDepthStencilValue;
+
+-typedef union {
++typedef union VkClearValue {
+ VkClearColorValue color;
+ VkClearDepthStencilValue depthStencil;
+ } VkClearValue;
+
+-typedef struct {
++typedef struct VkClearAttachment {
+ VkImageAspectFlags aspectMask;
+ uint32_t colorAttachment;
+ VkClearValue clearValue;
+ } VkClearAttachment;
+
+-typedef struct {
++typedef struct VkClearRect {
+ VkRect2D rect;
+ uint32_t baseArrayLayer;
+ uint32_t layerCount;
+ } VkClearRect;
+
+-typedef struct {
++typedef struct VkImageResolve {
+ VkImageSubresourceLayers srcSubresource;
+ VkOffset3D srcOffset;
+ VkImageSubresourceLayers dstSubresource;
+@@ -2075,7 +2063,7 @@ typedef struct {
+ VkExtent3D extent;
+ } VkImageResolve;
+
+-typedef struct {
++typedef struct VkRenderPassBeginInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkRenderPass renderPass;
+@@ -2085,11 +2073,11 @@ typedef struct {
+ const VkClearValue* pClearValues;
+ } VkRenderPassBeginInfo;
+
+-typedef struct {
++typedef struct VkBufferMemoryBarrier {
+ VkStructureType sType;
+ const void* pNext;
+- VkMemoryOutputFlags outputMask;
+- VkMemoryInputFlags inputMask;
++ VkAccessFlags srcAccessMask;
++ VkAccessFlags dstAccessMask;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ VkBuffer buffer;
+@@ -2097,13 +2085,13 @@ typedef struct {
+ VkDeviceSize size;
+ } VkBufferMemoryBarrier;
+
+-typedef struct {
++typedef struct VkDispatchIndirectCommand {
+ uint32_t x;
+ uint32_t y;
+ uint32_t z;
+ } VkDispatchIndirectCommand;
+
+-typedef struct {
++typedef struct VkDrawIndexedIndirectCommand {
+ uint32_t indexCount;
+ uint32_t instanceCount;
+ uint32_t firstIndex;
+@@ -2111,18 +2099,18 @@ typedef struct {
+ uint32_t firstInstance;
+ } VkDrawIndexedIndirectCommand;
+
+-typedef struct {
++typedef struct VkDrawIndirectCommand {
+ uint32_t vertexCount;
+ uint32_t instanceCount;
+ uint32_t firstVertex;
+ uint32_t firstInstance;
+ } VkDrawIndirectCommand;
+
+-typedef struct {
++typedef struct VkImageMemoryBarrier {
+ VkStructureType sType;
+ const void* pNext;
+- VkMemoryOutputFlags outputMask;
+- VkMemoryInputFlags inputMask;
++ VkAccessFlags srcAccessMask;
++ VkAccessFlags dstAccessMask;
+ VkImageLayout oldLayout;
+ VkImageLayout newLayout;
+ uint32_t srcQueueFamilyIndex;
+@@ -2131,11 +2119,11 @@ typedef struct {
+ VkImageSubresourceRange subresourceRange;
+ } VkImageMemoryBarrier;
+
+-typedef struct {
++typedef struct VkMemoryBarrier {
+ VkStructureType sType;
+ const void* pNext;
+- VkMemoryOutputFlags outputMask;
+- VkMemoryInputFlags inputMask;
++ VkAccessFlags srcAccessMask;
++ VkAccessFlags dstAccessMask;
+ } VkMemoryBarrier;
+
+
+@@ -2200,8 +2188,6 @@ typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageVi
+ typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
+ typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader);
+-typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
+ typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+@@ -2606,17 +2592,6 @@ void VKAPI vkDestroyShaderModule(
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkCreateShader(
+- VkDevice device,
+- const VkShaderCreateInfo* pCreateInfo,
+- const VkAllocationCallbacks* pAllocator,
+- VkShader* pShader);
+-
+-void VKAPI vkDestroyShader(
+- VkDevice device,
+- VkShader shader,
+- const VkAllocationCallbacks* pAllocator);
+-
+ VkResult VKAPI vkCreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+@@ -3079,16 +3054,16 @@ void VKAPI vkCmdExecuteCommands(
+ const VkCommandBuffer* pCommandBuffers);
+ #endif
+
+-#define vk_ext_khr_surface 1
++#define vk_khr_surface 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
+
+-#define VK_EXT_KHR_SURFACE_REVISION 20
+-#define VK_EXT_KHR_SURFACE_EXTENSION_NUMBER 1
+-#define VK_EXT_KHR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_surface"
++#define VK_KHR_SURFACE_REVISION 22
++#define VK_KHR_SURFACE_EXTENSION_NUMBER 1
++#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"
+ #define VK_ERROR_SURFACE_LOST_KHR ((VkResult)(int)0xc0000400)
+
+
+-typedef enum {
++typedef enum VkSurfaceTransformKHR {
+ VK_SURFACE_TRANSFORM_NONE_KHR = 0,
+ VK_SURFACE_TRANSFORM_ROT90_KHR = 1,
+ VK_SURFACE_TRANSFORM_ROT180_KHR = 2,
+@@ -3104,7 +3079,7 @@ typedef enum {
+ VK_SURFACE_TRANSFORM_MAX_ENUM = 0x7FFFFFFF
+ } VkSurfaceTransformKHR;
+
+-typedef enum {
++typedef enum VkColorSpaceKHR {
+ VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0,
+ VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
+ VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
+@@ -3112,7 +3087,7 @@ typedef enum {
+ VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF
+ } VkColorSpaceKHR;
+
+-typedef enum {
++typedef enum VkPresentModeKHR {
+ VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
+ VK_PRESENT_MODE_MAILBOX_KHR = 1,
+ VK_PRESENT_MODE_FIFO_KHR = 2,
+@@ -3124,7 +3099,7 @@ typedef enum {
+ } VkPresentModeKHR;
+
+
+-typedef enum {
++typedef enum VkSurfaceTransformFlagBitsKHR {
+ VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
+ VK_SURFACE_TRANSFORM_ROT90_BIT_KHR = 0x00000002,
+ VK_SURFACE_TRANSFORM_ROT180_BIT_KHR = 0x00000004,
+@@ -3137,7 +3112,7 @@ typedef enum {
+ } VkSurfaceTransformFlagBitsKHR;
+ typedef VkFlags VkSurfaceTransformFlagsKHR;
+
+-typedef enum {
++typedef enum VkCompositeAlphaFlagBitsKHR {
+ VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
+ VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
+ VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
+@@ -3145,7 +3120,7 @@ typedef enum {
+ } VkCompositeAlphaFlagBitsKHR;
+ typedef VkFlags VkCompositeAlphaFlagsKHR;
+
+-typedef struct {
++typedef struct VkSurfaceCapabilitiesKHR {
+ uint32_t minImageCount;
+ uint32_t maxImageCount;
+ VkExtent2D currentExtent;
+@@ -3158,7 +3133,7 @@ typedef struct {
+ VkImageUsageFlags supportedUsageFlags;
+ } VkSurfaceCapabilitiesKHR;
+
+-typedef struct {
++typedef struct VkSurfaceFormatKHR {
+ VkFormat format;
+ VkColorSpaceKHR colorSpace;
+ } VkSurfaceFormatKHR;
+@@ -3199,19 +3174,19 @@ VkResult VKAPI vkGetPhysicalDeviceSurfacePresentModesKHR(
+ VkPresentModeKHR* pPresentModes);
+ #endif
+
+-#define vk_ext_khr_swapchain 1
++#define vk_khr_swapchain 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
+
+-#define VK_EXT_KHR_SWAPCHAIN_REVISION 62
+-#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+-#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
++#define VK_KHR_SWAPCHAIN_REVISION 64
++#define VK_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
++#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
+ #define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
+ #define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801)
+ #define VK_IMAGE_LAYOUT_PRESENT_SRC_KHR ((VkImageLayout)(int)0xc0000802)
+ #define VK_SUBOPTIMAL_KHR ((VkResult)(int)0x40000403)
+ #define VK_ERROR_OUT_OF_DATE_KHR ((VkResult)(int)0xc0000804)
+
+-typedef struct {
++typedef struct VkSwapchainCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkSurfaceKHR surface;
+@@ -3231,7 +3206,7 @@ typedef struct {
+ VkBool32 clipped;
+ } VkSwapchainCreateInfoKHR;
+
+-typedef struct {
++typedef struct VkPresentInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t waitSemaphoreCount;
+@@ -3277,25 +3252,25 @@ VkResult VKAPI vkQueuePresentKHR(
+ VkPresentInfoKHR* pPresentInfo);
+ #endif
+
+-#define vk_ext_khr_display 1
++#define vk_khr_display 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
+
+-#define VK_EXT_KHR_DISPLAY_REVISION 17
+-#define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 3
+-#define VK_EXT_KHR_DISPLAY_EXTENSION_NAME "VK_EXT_KHR_display"
++#define VK_KHR_DISPLAY_REVISION 18
++#define VK_KHR_DISPLAY_EXTENSION_NUMBER 3
++#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"
+ #define VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c00)
+ #define VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c01)
+
+
+-typedef enum {
++typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
+ VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000001,
+ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000002,
+ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000004,
+ } VkDisplayPlaneAlphaFlagBitsKHR;
+ typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
+
+-typedef struct {
++typedef struct VkDisplayPropertiesKHR {
+ VkDisplayKHR display;
+ const char* displayName;
+ VkExtent2D physicalDimensions;
+@@ -3305,23 +3280,23 @@ typedef struct {
+ VkBool32 persistentContent;
+ } VkDisplayPropertiesKHR;
+
+-typedef struct {
++typedef struct VkDisplayModeParametersKHR {
+ VkExtent2D visibleRegion;
+ uint32_t refreshRate;
+ } VkDisplayModeParametersKHR;
+
+-typedef struct {
++typedef struct VkDisplayModePropertiesKHR {
+ VkDisplayModeKHR displayMode;
+ VkDisplayModeParametersKHR parameters;
+ } VkDisplayModePropertiesKHR;
+
+-typedef struct {
++typedef struct VkDisplayModeCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkDisplayModeParametersKHR parameters;
+ } VkDisplayModeCreateInfoKHR;
+
+-typedef struct {
++typedef struct VkDisplayPlaneCapabilitiesKHR {
+ VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
+ VkOffset2D minSrcPosition;
+ VkOffset2D maxSrcPosition;
+@@ -3333,12 +3308,12 @@ typedef struct {
+ VkExtent2D maxDstExtent;
+ } VkDisplayPlaneCapabilitiesKHR;
+
+-typedef struct {
++typedef struct VkDisplayPlanePropertiesKHR {
+ VkDisplayKHR currentDisplay;
+ uint32_t currentStackIndex;
+ } VkDisplayPlanePropertiesKHR;
+
+-typedef struct {
++typedef struct VkDisplaySurfaceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkDisplayModeKHR displayMode;
+@@ -3399,21 +3374,21 @@ VkResult VKAPI vkCreateDisplayPlaneSurfaceKHR(
+ VkSurfaceKHR* pSurface);
+ #endif
+
+-#define vk_ext_khr_display_swapchain 1
+-#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_REVISION 6
+-#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4
+-#define VK_EXT_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_display_swapchain"
++#define vk_khr_display_swapchain 1
++#define VK_KHR_DISPLAY_SWAPCHAIN_REVISION 7
++#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4
++#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
+ #define VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0001000)
+ #define VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0001001)
+ #define VK_ERROR_INCOMPATIBLE_DISPLAY_KHR ((VkResult)(int)0xc0001002)
+
+-typedef struct {
++typedef struct VkDisplaySwapchainCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ const VkSwapchainCreateInfoKHR* pNextSwapchainCreateInfo;
+ } VkDisplaySwapchainCreateInfoKHR;
+
+-typedef struct {
++typedef struct VkDisplayPresentInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkRect2D srcRect;
+@@ -3424,12 +3399,12 @@ typedef struct {
+
+
+ #ifdef VK_USE_PLATFORM_XLIB_KHR
+-#define vk_ext_khr_xlib_surface 1
++#define vk_khr_xlib_surface 1
+ #include <X11/Xlib.h>
+
+-#define VK_EXT_KHR_XLIB_SURFACE_REVISION 3
+-#define VK_EXT_KHR_XLIB_SURFACE_EXTENSION_NUMBER 5
+-#define VK_EXT_KHR_XLIB_SURFACE_EXTENSION_NAME "vk_ext_khr_xlib_surface"
++#define VK_KHR_XLIB_SURFACE_REVISION 4
++#define VK_KHR_XLIB_SURFACE_EXTENSION_NUMBER 5
++#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "vk_khr_xlib_surface"
+
+ typedef VkResult (VKAPI *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, VkSurfaceKHR* pSurface);
+ typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
+@@ -3450,12 +3425,12 @@ VkBool32 VKAPI vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ #endif /* VK_USE_PLATFORM_XLIB_KHR */
+
+ #ifdef VK_USE_PLATFORM_XCB_KHR
+-#define vk_ext_khr_xcb_surface 1
++#define vk_khr_xcb_surface 1
+ #include <xcb/xcb.h>
+
+-#define VK_EXT_KHR_XCB_SURFACE_REVISION 3
+-#define VK_EXT_KHR_XCB_SURFACE_EXTENSION_NUMBER 6
+-#define VK_EXT_KHR_XCB_SURFACE_EXTENSION_NAME "VK_EXT_KHR_xcb_surface"
++#define VK_KHR_XCB_SURFACE_REVISION 4
++#define VK_KHR_XCB_SURFACE_EXTENSION_NUMBER 6
++#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
+
+ typedef VkResult (VKAPI *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, xcb_connection_t* connection, xcb_window_t window, VkSurfaceKHR* pSurface);
+ typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
+@@ -3476,12 +3451,12 @@ VkBool32 VKAPI vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ #endif /* VK_USE_PLATFORM_XCB_KHR */
+
+ #ifdef VK_USE_PLATFORM_WAYLAND_KHR
+-#define vk_ext_khr_wayland_surface 1
++#define vk_khr_wayland_surface 1
+ #include <wayland-client.h>
+
+-#define VK_EXT_KHR_WAYLAND_SURFACE_REVISION 2
+-#define VK_EXT_KHR_WAYLAND_SURFACE_EXTENSION_NUMBER 7
+-#define VK_EXT_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_EXT_KHR_wayland_surface"
++#define VK_KHR_WAYLAND_SURFACE_REVISION 3
++#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NUMBER 7
++#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
+
+ typedef VkResult (VKAPI *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, struct wl_display* display, struct wl_surface* surface, VkSurfaceKHR* pSurface);
+ typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
+@@ -3501,12 +3476,12 @@ VkBool32 VKAPI vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
+
+ #ifdef VK_USE_PLATFORM_MIR_KHR
+-#define vk_ext_khr_mir_surface 1
++#define vk_khr_mir_surface 1
+ #include <mir_toolkit/client_types.h>
+
+-#define VK_EXT_KHR_MIR_SURFACE_REVISION 2
+-#define VK_EXT_KHR_MIR_SURFACE_EXTENSION_NUMBER 8
+-#define VK_EXT_KHR_MIR_SURFACE_EXTENSION_NAME "VK_EXT_KHR_mir_surface"
++#define VK_KHR_MIR_SURFACE_REVISION 3
++#define VK_KHR_MIR_SURFACE_EXTENSION_NUMBER 8
++#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
+
+ typedef VkResult (VKAPI *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, MirConnection* connection, MirSurface* mirSurface, VkSurfaceKHR* pSurface);
+ typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
+@@ -3526,12 +3501,12 @@ VkBool32 VKAPI vkGetPhysicalDeviceMirPresentationSupportKHR(
+ #endif /* VK_USE_PLATFORM_MIR_KHR */
+
+ #ifdef VK_USE_PLATFORM_ANDROID_KHR
+-#define vk_ext_khr_android_surface 1
++#define vk_khr_android_surface 1
+ #include <android/native_window.h>
+
+-#define VK_EXT_KHR_ANDROID_SURFACE_REVISION 1
+-#define VK_EXT_KHR_ANDROID_SURFACE_EXTENSION_NUMBER 9
+-#define VK_EXT_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_EXT_KHR_android_surface"
++#define VK_KHR_ANDROID_SURFACE_REVISION 2
++#define VK_KHR_ANDROID_SURFACE_EXTENSION_NUMBER 9
++#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
+ #define VK_ERROR_INVALID_ANDROID_WINDOW_KHR ((VkResult)(int)0xc0002400)
+ #define VK_ERROR_ANDROID_WINDOW_IN_USE_KHR ((VkResult)(int)0xc0002401)
+
+@@ -3546,12 +3521,12 @@ VkResult VKAPI vkCreateAndroidSurfaceKHR(
+ #endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
+ #ifdef VK_USE_PLATFORM_WIN32_KHR
+-#define vk_ext_khr_win32_surface 1
++#define vk_khr_win32_surface 1
+ #include <windows.h>
+
+-#define VK_EXT_KHR_WIN32_SURFACE_REVISION 2
+-#define VK_EXT_KHR_WIN32_SURFACE_EXTENSION_NUMBER 10
+-#define VK_EXT_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_EXT_KHR_win32_surface"
++#define VK_KHR_WIN32_SURFACE_REVISION 3
++#define VK_KHR_WIN32_SURFACE_EXTENSION_NUMBER 10
++#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
+
+ typedef VkResult (VKAPI *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, HINSTANCE hinstance, HWND hwnd, VkSurfaceKHR* pSurface);
+ typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 2b7faa9..9037e17 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -347,16 +347,6 @@ void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const V
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader) {
+- return GetVtbl(device).CreateShader(device, pCreateInfo, pAllocator, pShader);
+-}
+-
+-__attribute__((visibility("default")))
+-void vkDestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator) {
+- GetVtbl(device).DestroyShader(device, shader, pAllocator);
+-}
+-
+-__attribute__((visibility("default")))
+ VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
+ return GetVtbl(device).CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+ }
+diff --git a/vulkan/libvulkan/entry.cpp.tmpl b/vulkan/libvulkan/entry.cpp.tmpl
+index 5aed3df..712558b 100644
+--- a/vulkan/libvulkan/entry.cpp.tmpl
++++ b/vulkan/libvulkan/entry.cpp.tmpl
+@@ -94,9 +94,9 @@ namespace {
+ {{$ext := GetAnnotation $ "extension"}}
+ {{if $ext}}
+ {{$extval := index $ext.Arguments 0}}
+- {{if eq $extval "VK_EXT_KHR_surface"}}true
+- {{else if eq $extval "VK_EXT_KHR_swapchain"}}true
+- {{else if eq $extval "VK_EXT_KHR_android_surface"}}true{{end}}
++ {{if eq $extval "VK_KHR_surface"}}true
++ {{else if eq $extval "VK_KHR_swapchain"}}true
++ {{else if eq $extval "VK_KHR_android_surface"}}true{{end}}
+ {{else}}true{{end}}
+ {{end}}
+
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
+index f6a6510..7f1f54e 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp
++++ b/vulkan/libvulkan/get_proc_addr.cpp
+@@ -142,7 +142,6 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkCreateRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass)},
+ {"vkCreateSampler", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSampler)},
+ {"vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSemaphore)},
+- {"vkCreateShader", reinterpret_cast<PFN_vkVoidFunction>(vkCreateShader)},
+ {"vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkCreateShaderModule)},
+ {"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR)},
+ {"vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer)},
+@@ -163,7 +162,6 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkDestroyRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyRenderPass)},
+ {"vkDestroySampler", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySampler)},
+ {"vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySemaphore)},
+- {"vkDestroyShader", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShader)},
+ {"vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderModule)},
+ {"vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR)},
+ {"vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkDeviceWaitIdle)},
+@@ -299,7 +297,6 @@ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ {"vkCreateRenderPass", offsetof(DeviceVtbl, CreateRenderPass)},
+ {"vkCreateSampler", offsetof(DeviceVtbl, CreateSampler)},
+ {"vkCreateSemaphore", offsetof(DeviceVtbl, CreateSemaphore)},
+- {"vkCreateShader", offsetof(DeviceVtbl, CreateShader)},
+ {"vkCreateShaderModule", offsetof(DeviceVtbl, CreateShaderModule)},
+ {"vkCreateSwapchainKHR", offsetof(DeviceVtbl, CreateSwapchainKHR)},
+ {"vkDestroyBuffer", offsetof(DeviceVtbl, DestroyBuffer)},
+@@ -320,7 +317,6 @@ const NameOffsetEntry kDeviceOffsetTbl[] = {
+ {"vkDestroyRenderPass", offsetof(DeviceVtbl, DestroyRenderPass)},
+ {"vkDestroySampler", offsetof(DeviceVtbl, DestroySampler)},
+ {"vkDestroySemaphore", offsetof(DeviceVtbl, DestroySemaphore)},
+- {"vkDestroyShader", offsetof(DeviceVtbl, DestroyShader)},
+ {"vkDestroyShaderModule", offsetof(DeviceVtbl, DestroyShaderModule)},
+ {"vkDestroySwapchainKHR", offsetof(DeviceVtbl, DestroySwapchainKHR)},
+ {"vkDeviceWaitIdle", offsetof(DeviceVtbl, DeviceWaitIdle)},
+@@ -725,16 +721,6 @@ bool LoadDeviceVtbl(VkDevice device,
+ ALOGE("missing device proc: %s", "vkDestroyShaderModule");
+ success = false;
+ }
+- vtbl.CreateShader = reinterpret_cast<PFN_vkCreateShader>(get_proc_addr(device, "vkCreateShader"));
+- if (UNLIKELY(!vtbl.CreateShader)) {
+- ALOGE("missing device proc: %s", "vkCreateShader");
+- success = false;
+- }
+- vtbl.DestroyShader = reinterpret_cast<PFN_vkDestroyShader>(get_proc_addr(device, "vkDestroyShader"));
+- if (UNLIKELY(!vtbl.DestroyShader)) {
+- ALOGE("missing device proc: %s", "vkDestroyShader");
+- success = false;
+- }
+ vtbl.CreatePipelineCache = reinterpret_cast<PFN_vkCreatePipelineCache>(get_proc_addr(device, "vkCreatePipelineCache"));
+ if (UNLIKELY(!vtbl.CreatePipelineCache)) {
+ ALOGE("missing device proc: %s", "vkCreatePipelineCache");
+@@ -1166,7 +1152,7 @@ bool LoadDeviceVtbl(VkDevice device,
+ vtbl.QueueSignalNativeFenceANDROID = reinterpret_cast<PFN_vkQueueSignalNativeFenceANDROID>(get_proc_addr(device, "vkQueueSignalNativeFenceANDROID"));
+ if (!((!vtbl.AcquireImageANDROID && !vtbl.QueueSignalReleaseImageANDROID && vtbl.ImportNativeFenceANDROID && vtbl.QueueSignalNativeFenceANDROID) ||
+ (vtbl.AcquireImageANDROID && vtbl.QueueSignalReleaseImageANDROID && !vtbl.ImportNativeFenceANDROID && !vtbl.QueueSignalNativeFenceANDROID))) {
+- ALOGE("driver doesn't support exactly one of old- or new-style VK_EXT_ANDROID_native_buffer commands");
++ ALOGE("driver doesn't support exactly one of old- or new-style VK_ANDROID_native_buffer commands");
+ success = false;
+ }
+ // clang-format on
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp.tmpl b/vulkan/libvulkan/get_proc_addr.cpp.tmpl
+index 217647f..aad177d 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp.tmpl
++++ b/vulkan/libvulkan/get_proc_addr.cpp.tmpl
+@@ -255,7 +255,7 @@ bool LoadDeviceVtbl(VkDevice device,
+ vtbl.QueueSignalNativeFenceANDROID = reinterpret_cast<PFN_vkQueueSignalNativeFenceANDROID>(get_proc_addr(device, "vkQueueSignalNativeFenceANDROID"));
+ if (!((!vtbl.AcquireImageANDROID && !vtbl.QueueSignalReleaseImageANDROID && vtbl.ImportNativeFenceANDROID && vtbl.QueueSignalNativeFenceANDROID) ||
+ (vtbl.AcquireImageANDROID && vtbl.QueueSignalReleaseImageANDROID && !vtbl.ImportNativeFenceANDROID && !vtbl.QueueSignalNativeFenceANDROID))) {
+- ALOGE("driver doesn't support exactly one of old- or new-style VK_EXT_ANDROID_native_buffer commands");
++ ALOGE("driver doesn't support exactly one of old- or new-style VK_ANDROID_native_buffer commands");
+ success = false;
+ }
+ // clang-format on
+@@ -277,13 +277,13 @@ bool LoadDeviceVtbl(VkDevice device,
+ */}}
+ {{define "IsUnsupportedExtension"}}
+ {{$ext := index $.Arguments 0}}
+- {{ if eq $ext "VK_EXT_KHR_display"}}true
+- {{else if eq $ext "VK_EXT_KHR_display_swapchain"}}true
+- {{else if eq $ext "VK_EXT_KHR_xlib_surface"}}true
+- {{else if eq $ext "VK_EXT_KHR_xcb_surface"}}true
+- {{else if eq $ext "VK_EXT_KHR_wayland_surface"}}true
+- {{else if eq $ext "VK_EXT_KHR_mir_surface"}}true
+- {{else if eq $ext "VK_EXT_KHR_win32_surface"}}true
++ {{ if eq $ext "VK_KHR_display"}}true
++ {{else if eq $ext "VK_KHR_display_swapchain"}}true
++ {{else if eq $ext "VK_KHR_xlib_surface"}}true
++ {{else if eq $ext "VK_KHR_xcb_surface"}}true
++ {{else if eq $ext "VK_KHR_wayland_surface"}}true
++ {{else if eq $ext "VK_KHR_mir_surface"}}true
++ {{else if eq $ext "VK_KHR_win32_surface"}}true
+ {{end}}
+ {{end}}
+
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index bf71c8f..5765d65 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -20,7 +20,7 @@
+ #define VK_PROTOTYPES
+ #define VK_USE_PLATFORM_ANDROID_KHR
+ #include <vulkan/vulkan.h>
+-#include <vulkan/vk_ext_android_native_buffer.h>
++#include <vulkan/vk_android_native_buffer.h>
+
+ namespace vulkan {
+
+@@ -105,8 +105,6 @@ struct DeviceVtbl {
+ PFN_vkDestroyImageView DestroyImageView;
+ PFN_vkCreateShaderModule CreateShaderModule;
+ PFN_vkDestroyShaderModule DestroyShaderModule;
+- PFN_vkCreateShader CreateShader;
+- PFN_vkDestroyShader DestroyShader;
+ PFN_vkCreatePipelineCache CreatePipelineCache;
+ PFN_vkDestroyPipelineCache DestroyPipelineCache;
+ PFN_vkGetPipelineCacheData GetPipelineCacheData;
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 85d018b..e75eb3a 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -81,7 +81,6 @@ enum Enum {
+ kRenderPass,
+ kSampler,
+ kSemaphore,
+- kShader,
+ kShaderModule,
+
+ kNumTypes
+@@ -705,14 +704,6 @@ VkResult CreateSemaphore(VkDevice device,
+ return VK_SUCCESS;
+ }
+
+-VkResult CreateShader(VkDevice device,
+- const VkShaderCreateInfo*,
+- const VkAllocationCallbacks* /*allocator*/,
+- VkShader* shader) {
+- *shader = AllocHandle(device, HandleType::kShader);
+- return VK_SUCCESS;
+-}
+-
+ VkResult CreateShaderModule(VkDevice device,
+ const VkShaderModuleCreateInfo*,
+ const VkAllocationCallbacks* /*allocator*/,
+@@ -884,9 +875,6 @@ void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocation
+ void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator) {
+ }
+
+-void DestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* allocator) {
+-}
+-
+ void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator) {
+ }
+
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 91b8d34..6d14e57 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -19,7 +19,7 @@
+
+ #define VK_PROTOTYPES
+ #include <vulkan/vulkan.h>
+-#include <vulkan/vk_ext_android_native_buffer.h>
++#include <vulkan/vk_android_native_buffer.h>
+
+ namespace null_driver {
+
+@@ -87,8 +87,6 @@ VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateIn
+ void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator);
+ VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkShaderModule* pShaderModule);
+ void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator);
+-VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkShader* pShader);
+-void DestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* allocator);
+ VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkPipelineCache* pPipelineCache);
+ void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator);
+ VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
+index 9b1b042..c732131 100644
+--- a/vulkan/nulldrv/null_driver_gen.cpp
++++ b/vulkan/nulldrv/null_driver_gen.cpp
+@@ -135,7 +135,6 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkCreateRenderPass", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateRenderPass>(CreateRenderPass))},
+ {"vkCreateSampler", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateSampler>(CreateSampler))},
+ {"vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateSemaphore>(CreateSemaphore))},
+- {"vkCreateShader", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateShader>(CreateShader))},
+ {"vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateShaderModule>(CreateShaderModule))},
+ {"vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyBuffer>(DestroyBuffer))},
+ {"vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyBufferView>(DestroyBufferView))},
+@@ -155,7 +154,6 @@ const NameProcEntry kDeviceProcTbl[] = {
+ {"vkDestroyRenderPass", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyRenderPass>(DestroyRenderPass))},
+ {"vkDestroySampler", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroySampler>(DestroySampler))},
+ {"vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroySemaphore>(DestroySemaphore))},
+- {"vkDestroyShader", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyShader>(DestroyShader))},
+ {"vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyShaderModule>(DestroyShaderModule))},
+ {"vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDeviceWaitIdle>(DeviceWaitIdle))},
+ {"vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEndCommandBuffer>(EndCommandBuffer))},
+--
+2.4.0
+
--- /dev/null
+From 579a86538c32f14824b80de1d27382e85a4f24f2 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 30 Nov 2015 00:55:29 -0800
+Subject: [PATCH 22/30] vulkan: Update from version 0.200.0 to 0.202.0
+
+Change-Id: If8eb49cd7e5516931f9900b691d6d32af2aa98b0
+---
+ vulkan/api/vulkan.api | 45 +++++++++++++------------
+ vulkan/include/vulkan/vulkan.h | 74 +++++++++++++++++++++++-------------------
+ vulkan/libvulkan/entry.cpp | 2 +-
+ vulkan/libvulkan/loader.cpp | 2 +-
+ vulkan/libvulkan/swapchain.cpp | 2 +-
+ vulkan/nulldrv/null_driver.cpp | 2 +-
+ vulkan/nulldrv/null_driver.h | 2 +-
+ 7 files changed, 71 insertions(+), 58 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 0296b0f..89ed617 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 200
++define VERSION_MINOR 202
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -243,7 +243,7 @@ enum VkPrimitiveTopology {
+ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 0x00000007,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 0x00000008,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 0x00000009,
+- VK_PRIMITIVE_TOPOLOGY_PATCH = 0x0000000a,
++ VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 0x0000000a,
+ }
+
+ enum VkSharingMode {
+@@ -628,7 +628,7 @@ enum VkSubpassContents {
+ VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 0x00000001,
+ }
+
+-@lastUnused(-8)
++@lastUnused(-10)
+ /// Error and return codes
+ enum VkResult {
+ // Return codes for successful operation execution (positive values)
+@@ -652,6 +652,7 @@ enum VkResult {
+ VK_ERROR_EXTENSION_NOT_PRESENT = 0xFFFFFFF9,
+ VK_ERROR_FEATURE_NOT_PRESENT = 0xFFFFFFF8,
+ VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF7,
++ VK_ERROR_TOO_MANY_OBJECTS = 0xFFFFFFF6,
+
+ //@extension("VK_KHR_surface")
+ VK_ERROR_SURFACE_LOST_KHR = 0xC0000400,
+@@ -942,8 +943,9 @@ bitfield VkImageAspectFlagBits {
+
+ /// Sparse memory bind flags
+ type VkFlags VkSparseMemoryBindFlags
+-//bitfield VkSparseMemoryBindFlagBits {
+-//}
++bitfield VkSparseMemoryBindFlagBits {
++ VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
++}
+
+ /// Sparse image memory requirements flags
+ type VkFlags VkSparseImageFormatFlags
+@@ -971,8 +973,8 @@ bitfield VkPipelineStageFlagBits {
+ VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, /// Transfer/copy operations
+ VK_PIPELINE_STAGE_HOST_BIT = 0x00002000, /// Indicates host (CPU) is a source/sink of the dependency
+
+- VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF, /// All stages of the graphics pipeline
+- VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00001FFF, /// All graphics, compute, copy, and transition commands
++ VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00004000, /// All stages of the graphics pipeline
++ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00008000, /// All graphics, compute, copy, and transition commands
+ }
+
+ /// Render pass attachment description flags
+@@ -1504,7 +1506,7 @@ class VkImageCreateInfo {
+ VkExtent3D extent
+ u32 mipLevels
+ u32 arrayLayers
+- u32 samples
++ VkSampleCountFlagBits samples
+ VkImageTiling tiling
+ VkImageUsageFlags usage /// Image usage flags
+ VkSharingMode sharingMode /// Cross-queue-family sharing mode
+@@ -1637,6 +1639,7 @@ class VkShaderModuleCreateInfo {
+ }
+
+ class VkDescriptorSetLayoutBinding {
++ u32 binding
+ VkDescriptorType descriptorType /// Type of the descriptors in this binding
+ u32 arraySize /// Number of descriptors in this binding
+ VkShaderStageFlags stageFlags /// Shader stages this binding is visible to
+@@ -1774,7 +1777,7 @@ class VkPipelineMultisampleStateCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+ VkPipelineMultisampleStateCreateFlags flags
+- u32 rasterizationSamples /// Number of samples used for rasterization
++ VkSampleCountFlagBits rasterizationSamples /// Number of samples used for rasterization
+ VkBool32 sampleShadingEnable /// optional (GL45)
+ f32 minSampleShading /// optional (GL45)
+ const VkSampleMask* pSampleMask
+@@ -1966,7 +1969,7 @@ class VkClearAttachment {
+ class VkAttachmentDescription {
+ VkAttachmentDescriptionFlags flags
+ VkFormat format
+- u32 samples
++ VkSampleCountFlagBits samples
+ VkAttachmentLoadOp loadOp /// Load op for color or depth data
+ VkAttachmentStoreOp storeOp /// Store op for color or depth data
+ VkAttachmentLoadOp stencilLoadOp /// Load op for stencil data
+@@ -2090,13 +2093,13 @@ class VkPhysicalDeviceLimits {
+ u32 maxImageDimension3D /// max 3D image dimension
+ u32 maxImageDimensionCube /// max cubemap image dimension
+ u32 maxImageArrayLayers /// max layers for image arrays
+- VkSampleCountFlags sampleCounts /// sample counts supported for all images supporting rendering and sampling
+ u32 maxTexelBufferElements
+ u32 maxUniformBufferRange /// max uniform buffer size (bytes)
+ u32 maxStorageBufferRange /// max storage buffer size (bytes)
+ u32 maxPushConstantsSize /// max size of the push constants pool (bytes)
+ /// memory limits
+ u32 maxMemoryAllocationCount /// max number of device memory allocations supported
++ u32 maxSamplerAllocationCount
+ VkDeviceSize bufferImageGranularity /// Granularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage
+ VkDeviceSize sparseAddressSpaceSize /// Total address space available for sparse allocations (bytes)
+ /// descriptor set limits
+@@ -2176,16 +2179,17 @@ class VkPhysicalDeviceLimits {
+ u32 maxFramebufferWidth /// max width for a framebuffer
+ u32 maxFramebufferHeight /// max height for a framebuffer
+ u32 maxFramebufferLayers /// max layer count for a layered framebuffer
+- u32 maxFramebufferColorSamples /// max color sample count for a framebuffer
+- u32 maxFramebufferDepthSamples /// max depth sample count for a framebuffer
+- u32 maxFramebufferStencilSamples /// max stencil sample count for a framebuffer
++ VkSampleCountFlags framebufferColorSampleCounts
++ VkSampleCountFlags framebufferDepthSampleCounts
++ VkSampleCountFlags framebufferStencilSampleCounts
++ VkSampleCountFlags framebufferNoAttachmentSampleCounts
+ u32 maxColorAttachments /// max num of framebuffer color attachments
+
+- u32 maxSampledImageColorSamples /// max num of color samples for a non-integer sampled image
+- u32 maxSampledImageDepthSamples /// max num of depth samples for a sampled image
+- u32 maxSampledImageStencilSamples /// max num of stencil samples for a sampled image
+- u32 maxSampledImageIntegerSamples /// max num of samples supported for an integer image
+- u32 maxStorageImageSamples /// max num of samples for a storage image
++ VkSampleCountFlags sampledImageColorSampleCounts
++ VkSampleCountFlags sampledImageIntegerSampleCounts
++ VkSampleCountFlags sampledImageDepthSampleCounts
++ VkSampleCountFlags sampledImageStencilSampleCounts
++ VkSampleCountFlags storageImageSampleCounts
+ u32 maxSampleMaskWords /// max num of sample mask words
+
+ f32 timestampPeriod
+@@ -2201,6 +2205,7 @@ class VkPhysicalDeviceLimits {
+ f32 pointSizeGranularity /// granularity of supported point sizes
+ f32 lineWidthGranularity /// granularity of supported line widths
+ VkBool32 strictLines
++ VkBool32 standardSampleLocations
+
+ VkDeviceSize optimalBufferCopyOffsetAlignment
+ VkDeviceSize optimalBufferCopyRowPitchAlignment
+@@ -2948,7 +2953,7 @@ cmd void vkGetPhysicalDeviceSparseImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+- u32 samples,
++ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ u32* pPropertyCount,
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 2e66e27..ca00976 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 200, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 202, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -123,9 +123,10 @@ typedef enum VkResult {
+ VK_ERROR_EXTENSION_NOT_PRESENT = -7,
+ VK_ERROR_FEATURE_NOT_PRESENT = -8,
+ VK_ERROR_INCOMPATIBLE_DRIVER = -9,
+- VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER,
++ VK_ERROR_TOO_MANY_OBJECTS = -10,
++ VK_RESULT_BEGIN_RANGE = VK_ERROR_TOO_MANY_OBJECTS,
+ VK_RESULT_END_RANGE = VK_INCOMPLETE,
+- VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1),
++ VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_TOO_MANY_OBJECTS + 1),
+ VK_RESULT_MAX_ENUM = 0x7FFFFFFF
+ } VkResult;
+
+@@ -499,10 +500,10 @@ typedef enum VkPrimitiveTopology {
+ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
+- VK_PRIMITIVE_TOPOLOGY_PATCH = 10,
++ VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
+ VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
+- VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH,
+- VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
++ VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
++ VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
+ VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
+ } VkPrimitiveTopology;
+
+@@ -838,6 +839,10 @@ typedef enum VkSparseImageFormatFlagBits {
+ VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
+ } VkSparseImageFormatFlagBits;
+ typedef VkFlags VkSparseImageFormatFlags;
++
++typedef enum VkSparseMemoryBindFlagBits {
++ VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
++} VkSparseMemoryBindFlagBits;
+ typedef VkFlags VkSparseMemoryBindFlags;
+
+ typedef enum VkFenceCreateFlagBits {
+@@ -973,8 +978,8 @@ typedef enum VkPipelineStageFlagBits {
+ VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
+ VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
+ VK_PIPELINE_STAGE_HOST_BIT = 0x00002000,
+- VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF,
+- VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00001FFF,
++ VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00004000,
++ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00008000,
+ } VkPipelineStageFlagBits;
+ typedef VkFlags VkPipelineStageFlags;
+
+@@ -1183,12 +1188,12 @@ typedef struct VkPhysicalDeviceLimits {
+ uint32_t maxImageDimension3D;
+ uint32_t maxImageDimensionCube;
+ uint32_t maxImageArrayLayers;
+- VkSampleCountFlags sampleCounts;
+ uint32_t maxTexelBufferElements;
+ uint32_t maxUniformBufferRange;
+ uint32_t maxStorageBufferRange;
+ uint32_t maxPushConstantsSize;
+ uint32_t maxMemoryAllocationCount;
++ uint32_t maxSamplerAllocationCount;
+ VkDeviceSize bufferImageGranularity;
+ VkDeviceSize sparseAddressSpaceSize;
+ uint32_t maxBoundDescriptorSets;
+@@ -1255,15 +1260,16 @@ typedef struct VkPhysicalDeviceLimits {
+ uint32_t maxFramebufferWidth;
+ uint32_t maxFramebufferHeight;
+ uint32_t maxFramebufferLayers;
+- uint32_t maxFramebufferColorSamples;
+- uint32_t maxFramebufferDepthSamples;
+- uint32_t maxFramebufferStencilSamples;
++ VkSampleCountFlags framebufferColorSampleCounts;
++ VkSampleCountFlags framebufferDepthSampleCounts;
++ VkSampleCountFlags framebufferStencilSampleCounts;
++ VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
+ uint32_t maxColorAttachments;
+- uint32_t maxSampledImageColorSamples;
+- uint32_t maxSampledImageDepthSamples;
+- uint32_t maxSampledImageStencilSamples;
+- uint32_t maxSampledImageIntegerSamples;
+- uint32_t maxStorageImageSamples;
++ VkSampleCountFlags sampledImageColorSampleCounts;
++ VkSampleCountFlags sampledImageIntegerSampleCounts;
++ VkSampleCountFlags sampledImageDepthSampleCounts;
++ VkSampleCountFlags sampledImageStencilSampleCounts;
++ VkSampleCountFlags storageImageSampleCounts;
+ uint32_t maxSampleMaskWords;
+ float timestampPeriod;
+ uint32_t maxClipDistances;
+@@ -1275,6 +1281,7 @@ typedef struct VkPhysicalDeviceLimits {
+ float pointSizeGranularity;
+ float lineWidthGranularity;
+ VkBool32 strictLines;
++ VkBool32 standardSampleLocations;
+ VkDeviceSize optimalBufferCopyOffsetAlignment;
+ VkDeviceSize optimalBufferCopyRowPitchAlignment;
+ } VkPhysicalDeviceLimits;
+@@ -1522,7 +1529,7 @@ typedef struct VkImageCreateInfo {
+ VkExtent3D extent;
+ uint32_t mipLevels;
+ uint32_t arrayLayers;
+- uint32_t samples;
++ VkSampleCountFlagBits samples;
+ VkImageTiling tiling;
+ VkImageUsageFlags usage;
+ VkSharingMode sharingMode;
+@@ -1695,7 +1702,7 @@ typedef struct VkPipelineMultisampleStateCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkPipelineMultisampleStateCreateFlags flags;
+- uint32_t rasterizationSamples;
++ VkSampleCountFlagBits rasterizationSamples;
+ VkBool32 sampleShadingEnable;
+ float minSampleShading;
+ const VkSampleMask* pSampleMask;
+@@ -1827,6 +1834,7 @@ typedef struct VkSamplerCreateInfo {
+ } VkSamplerCreateInfo;
+
+ typedef struct VkDescriptorSetLayoutBinding {
++ uint32_t binding;
+ VkDescriptorType descriptorType;
+ uint32_t arraySize;
+ VkShaderStageFlags stageFlags;
+@@ -1915,7 +1923,7 @@ typedef struct VkFramebufferCreateInfo {
+ typedef struct VkAttachmentDescription {
+ VkAttachmentDescriptionFlags flags;
+ VkFormat format;
+- uint32_t samples;
++ VkSampleCountFlagBits samples;
+ VkAttachmentLoadOp loadOp;
+ VkAttachmentStoreOp storeOp;
+ VkAttachmentLoadOp stencilLoadOp;
+@@ -2160,7 +2168,7 @@ typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image,
+ typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+ typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+ typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+-typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
++typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
+ typedef VkResult (VKAPI *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
+ typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+ typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
+@@ -2437,7 +2445,7 @@ void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+- uint32_t samples,
++ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t* pPropertyCount,
+@@ -3054,7 +3062,7 @@ void VKAPI vkCmdExecuteCommands(
+ const VkCommandBuffer* pCommandBuffers);
+ #endif
+
+-#define vk_khr_surface 1
++#define VK_KHR_surface 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
+
+ #define VK_KHR_SURFACE_REVISION 22
+@@ -3174,7 +3182,7 @@ VkResult VKAPI vkGetPhysicalDeviceSurfacePresentModesKHR(
+ VkPresentModeKHR* pPresentModes);
+ #endif
+
+-#define vk_khr_swapchain 1
++#define VK_KHR_swapchain 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
+
+ #define VK_KHR_SWAPCHAIN_REVISION 64
+@@ -3252,7 +3260,7 @@ VkResult VKAPI vkQueuePresentKHR(
+ VkPresentInfoKHR* pPresentInfo);
+ #endif
+
+-#define vk_khr_display 1
++#define VK_KHR_display 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
+
+@@ -3374,7 +3382,7 @@ VkResult VKAPI vkCreateDisplayPlaneSurfaceKHR(
+ VkSurfaceKHR* pSurface);
+ #endif
+
+-#define vk_khr_display_swapchain 1
++#define VK_KHR_display_swapchain 1
+ #define VK_KHR_DISPLAY_SWAPCHAIN_REVISION 7
+ #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4
+ #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
+@@ -3399,12 +3407,12 @@ typedef struct VkDisplayPresentInfoKHR {
+
+
+ #ifdef VK_USE_PLATFORM_XLIB_KHR
+-#define vk_khr_xlib_surface 1
++#define VK_KHR_xlib_surface 1
+ #include <X11/Xlib.h>
+
+ #define VK_KHR_XLIB_SURFACE_REVISION 4
+ #define VK_KHR_XLIB_SURFACE_EXTENSION_NUMBER 5
+-#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "vk_khr_xlib_surface"
++#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
+
+ typedef VkResult (VKAPI *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, VkSurfaceKHR* pSurface);
+ typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
+@@ -3425,7 +3433,7 @@ VkBool32 VKAPI vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ #endif /* VK_USE_PLATFORM_XLIB_KHR */
+
+ #ifdef VK_USE_PLATFORM_XCB_KHR
+-#define vk_khr_xcb_surface 1
++#define VK_KHR_xcb_surface 1
+ #include <xcb/xcb.h>
+
+ #define VK_KHR_XCB_SURFACE_REVISION 4
+@@ -3451,7 +3459,7 @@ VkBool32 VKAPI vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ #endif /* VK_USE_PLATFORM_XCB_KHR */
+
+ #ifdef VK_USE_PLATFORM_WAYLAND_KHR
+-#define vk_khr_wayland_surface 1
++#define VK_KHR_wayland_surface 1
+ #include <wayland-client.h>
+
+ #define VK_KHR_WAYLAND_SURFACE_REVISION 3
+@@ -3476,7 +3484,7 @@ VkBool32 VKAPI vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
+
+ #ifdef VK_USE_PLATFORM_MIR_KHR
+-#define vk_khr_mir_surface 1
++#define VK_KHR_mir_surface 1
+ #include <mir_toolkit/client_types.h>
+
+ #define VK_KHR_MIR_SURFACE_REVISION 3
+@@ -3501,7 +3509,7 @@ VkBool32 VKAPI vkGetPhysicalDeviceMirPresentationSupportKHR(
+ #endif /* VK_USE_PLATFORM_MIR_KHR */
+
+ #ifdef VK_USE_PLATFORM_ANDROID_KHR
+-#define vk_khr_android_surface 1
++#define VK_KHR_android_surface 1
+ #include <android/native_window.h>
+
+ #define VK_KHR_ANDROID_SURFACE_REVISION 2
+@@ -3521,7 +3529,7 @@ VkResult VKAPI vkCreateAndroidSurfaceKHR(
+ #endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
+ #ifdef VK_USE_PLATFORM_WIN32_KHR
+-#define vk_khr_win32_surface 1
++#define VK_KHR_win32_surface 1
+ #include <windows.h>
+
+ #define VK_KHR_WIN32_SURFACE_REVISION 3
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 9037e17..0e01d4e 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -207,7 +207,7 @@ void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
++void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+ }
+
+diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
+index 246c37d..e0eddba 100644
+--- a/vulkan/libvulkan/loader.cpp
++++ b/vulkan/libvulkan/loader.cpp
+@@ -860,7 +860,7 @@ void GetPhysicalDeviceSparseImageFormatPropertiesBottom(
+ VkPhysicalDevice pdev,
+ VkFormat format,
+ VkImageType type,
+- uint32_t samples,
++ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t* properties_count,
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index 5b35506..d93a80f 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -405,7 +405,7 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ .extent = {0, 0, 1},
+ .mipLevels = 1,
+ .arrayLayers = 1,
+- .samples = 1,
++ .samples = VK_SAMPLE_COUNT_1_BIT,
+ .tiling = VK_IMAGE_TILING_OPTIMAL,
+ .usage = create_info->imageUsageFlags,
+ .flags = 0,
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index e75eb3a..8f0a0e5 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -808,7 +808,7 @@ void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t*
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ }
+
+-void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
++void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ }
+
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 6d14e57..0ed9cd0 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -59,7 +59,7 @@ VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkD
+ void GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+ void GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+ void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+-void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
++void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+ VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
+ VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkFence* pFence);
+ void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator);
+--
+2.4.0
+
--- /dev/null
+From 8fb824bebd02ae132ac846abbd225fde366f4798 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 30 Nov 2015 01:03:10 -0800
+Subject: [PATCH 23/30] vulkan: Update from version 0.202.0 to 0.203.0
+
+Change-Id: I21a390bd57082194f6131b118ecd6c94874d2f7f
+---
+ vulkan/api/vulkan.api | 10 +++++++---
+ vulkan/include/vulkan/vulkan.h | 30 ++++++++++++++++--------------
+ vulkan/libvulkan/entry.cpp | 4 ++--
+ vulkan/libvulkan/loader.cpp | 7 ++++---
+ vulkan/libvulkan/swapchain.cpp | 7 +++++++
+ vulkan/nulldrv/null_driver.cpp | 3 ++-
+ vulkan/nulldrv/null_driver.h | 2 +-
+ 7 files changed, 39 insertions(+), 24 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 89ed617..3966f87 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 202
++define VERSION_MINOR 203
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -49,7 +49,7 @@ define NULL_HANDLE 0
+ @extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NUMBER 1
+ @extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"
+
+-@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_REVISION 64
++@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_REVISION 65
+ @extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+ @extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
+
+@@ -653,6 +653,7 @@ enum VkResult {
+ VK_ERROR_FEATURE_NOT_PRESENT = 0xFFFFFFF8,
+ VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF7,
+ VK_ERROR_TOO_MANY_OBJECTS = 0xFFFFFFF6,
++ VK_ERROR_FORMAT_NOT_SUPPORTED = 0xFFFFFFF5,
+
+ //@extension("VK_KHR_surface")
+ VK_ERROR_SURFACE_LOST_KHR = 0xC0000400,
+@@ -2317,6 +2318,7 @@ class VkPresentInfoKHR {
+ u32 swapchainCount
+ const VkSwapchainKHR* pSwapchains
+ const u32* imageIndices
++ const VkResult* pResults
+ }
+
+ @extension("VK_KHR_display")
+@@ -2577,7 +2579,7 @@ cmd void vkGetPhysicalDeviceFormatProperties(
+ pFormatProperties[0] = formatProperties
+ }
+
+-cmd void vkGetPhysicalDeviceImageFormatProperties(
++cmd VkResult vkGetPhysicalDeviceImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+@@ -2589,6 +2591,8 @@ cmd void vkGetPhysicalDeviceImageFormatProperties(
+
+ imageFormatProperties := ?
+ pImageFormatProperties[0] = imageFormatProperties
++
++ return ?
+ }
+
+
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index ca00976..21bb796 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,11 +41,11 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 202, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 203, 0)
+
+
+ #define VK_NULL_HANDLE 0
+-
++
+
+
+ #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
+@@ -56,7 +56,7 @@ extern "C" {
+ #else
+ #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
+ #endif
+-
++
+
+
+ typedef uint32_t VkFlags;
+@@ -124,9 +124,10 @@ typedef enum VkResult {
+ VK_ERROR_FEATURE_NOT_PRESENT = -8,
+ VK_ERROR_INCOMPATIBLE_DRIVER = -9,
+ VK_ERROR_TOO_MANY_OBJECTS = -10,
+- VK_RESULT_BEGIN_RANGE = VK_ERROR_TOO_MANY_OBJECTS,
++ VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
++ VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED,
+ VK_RESULT_END_RANGE = VK_INCOMPLETE,
+- VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_TOO_MANY_OBJECTS + 1),
++ VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + 1),
+ VK_RESULT_MAX_ENUM = 0x7FFFFFFF
+ } VkResult;
+
+@@ -2140,7 +2141,7 @@ typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocat
+ typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+-typedef void (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
++typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+ typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+@@ -2297,7 +2298,7 @@ void VKAPI vkGetPhysicalDeviceFormatProperties(
+ VkFormat format,
+ VkFormatProperties* pFormatProperties);
+
+-void VKAPI vkGetPhysicalDeviceImageFormatProperties(
++VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+@@ -3185,7 +3186,7 @@ VkResult VKAPI vkGetPhysicalDeviceSurfacePresentModesKHR(
+ #define VK_KHR_swapchain 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
+
+-#define VK_KHR_SWAPCHAIN_REVISION 64
++#define VK_KHR_SWAPCHAIN_REVISION 65
+ #define VK_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+ #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
+ #define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
+@@ -3196,7 +3197,7 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
+
+ typedef struct VkSwapchainCreateInfoKHR {
+ VkStructureType sType;
+- const void* pNext;
++ const void* pNext;
+ VkSurfaceKHR surface;
+ uint32_t minImageCount;
+ VkFormat imageFormat;
+@@ -3216,12 +3217,13 @@ typedef struct VkSwapchainCreateInfoKHR {
+
+ typedef struct VkPresentInfoKHR {
+ VkStructureType sType;
+- const void* pNext;
++ const void* pNext;
+ uint32_t waitSemaphoreCount;
+ const VkSemaphore* pWaitSemaphores;
+ uint32_t swapchainCount;
+ const VkSwapchainKHR* pSwapchains;
+ const uint32_t* imageIndices;
++ VkResult* pResults;
+ } VkPresentInfoKHR;
+
+
+@@ -3300,7 +3302,7 @@ typedef struct VkDisplayModePropertiesKHR {
+
+ typedef struct VkDisplayModeCreateInfoKHR {
+ VkStructureType sType;
+- const void* pNext;
++ const void* pNext;
+ VkDisplayModeParametersKHR parameters;
+ } VkDisplayModeCreateInfoKHR;
+
+@@ -3323,7 +3325,7 @@ typedef struct VkDisplayPlanePropertiesKHR {
+
+ typedef struct VkDisplaySurfaceCreateInfoKHR {
+ VkStructureType sType;
+- const void* pNext;
++ const void* pNext;
+ VkDisplayModeKHR displayMode;
+ uint32_t planeIndex;
+ uint32_t planeStackIndex;
+@@ -3392,13 +3394,13 @@ VkResult VKAPI vkCreateDisplayPlaneSurfaceKHR(
+
+ typedef struct VkDisplaySwapchainCreateInfoKHR {
+ VkStructureType sType;
+- const void* pNext;
++ const void* pNext;
+ const VkSwapchainCreateInfoKHR* pNextSwapchainCreateInfo;
+ } VkDisplaySwapchainCreateInfoKHR;
+
+ typedef struct VkDisplayPresentInfoKHR {
+ VkStructureType sType;
+- const void* pNext;
++ const void* pNext;
+ VkRect2D srcRect;
+ VkRect2D dstRect;
+ VkBool32 persistent;
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 0e01d4e..fffb3eb 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -92,8 +92,8 @@ void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkForm
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+- GetVtbl(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
++VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
++ return GetVtbl(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+ }
+
+ __attribute__((visibility("default")))
+diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
+index e0eddba..135f06d 100644
+--- a/vulkan/libvulkan/loader.cpp
++++ b/vulkan/libvulkan/loader.cpp
+@@ -698,7 +698,7 @@ void GetPhysicalDeviceFormatPropertiesBottom(VkPhysicalDevice pdev,
+ pdev, format, properties);
+ }
+
+-void GetPhysicalDeviceImageFormatPropertiesBottom(
++VkResult GetPhysicalDeviceImageFormatPropertiesBottom(
+ VkPhysicalDevice pdev,
+ VkFormat format,
+ VkImageType type,
+@@ -706,8 +706,9 @@ void GetPhysicalDeviceImageFormatPropertiesBottom(
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* properties) {
+- GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceImageFormatProperties(
+- pdev, format, type, tiling, usage, flags, properties);
++ return GetVtbl(pdev)
++ ->instance->drv.vtbl.GetPhysicalDeviceImageFormatProperties(
++ pdev, format, type, tiling, usage, flags, properties);
+ }
+
+ void GetPhysicalDevicePropertiesBottom(VkPhysicalDevice pdev,
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index d93a80f..98faaef 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -631,6 +631,8 @@ VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info) {
+ }
+ if (result != VK_SUCCESS) {
+ ALOGE("QueueSignalReleaseImageANDROID failed: %d", result);
++ if (present_info->pResults)
++ present_info->pResults[sc] = result;
+ if (final_result == VK_SUCCESS)
+ final_result = result;
+ // TODO(jessehall): What happens to the buffer here? Does the app
+@@ -645,6 +647,8 @@ VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info) {
+ // TODO(jessehall): What now? We should probably cancel the buffer,
+ // I guess?
+ ALOGE("queueBuffer failed: %s (%d)", strerror(-err), err);
++ if (present_info->pResults)
++ present_info->pResults[sc] = result;
+ if (final_result == VK_SUCCESS)
+ final_result = VK_ERROR_INITIALIZATION_FAILED;
+ continue;
+@@ -655,6 +659,9 @@ VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info) {
+ img.dequeue_fence = -1;
+ }
+ img.dequeued = false;
++
++ if (present_info->pResults)
++ present_info->pResults[sc] = VK_SUCCESS;
+ }
+
+ return final_result;
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 8f0a0e5..316d27f 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -746,8 +746,9 @@ void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat
+ ALOGV("TODO: vk%s", __FUNCTION__);
+ }
+
+-void GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
++VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+ ALOGV("TODO: vk%s", __FUNCTION__);
++ return VK_SUCCESS;
+ }
+
+ VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 0ed9cd0..1a524ff 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -31,7 +31,7 @@ void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* allocator
+ VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+ void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+ void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+-void GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
++VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+ void GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+ void GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+ void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+--
+2.4.0
+
--- /dev/null
+From 5b17dda5e7ca170fd8743ae19152b1766c506436 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 30 Nov 2015 11:27:32 -0800
+Subject: [PATCH 24/30] vulkan: Update from version 0.203.0 to 0.204.0
+
+Change-Id: I2de0935df66b0110b566ed2025c39e0c17b98f17
+---
+ vulkan/api/vulkan.api | 6 +-
+ vulkan/include/vulkan/vk_android_native_buffer.h | 20 +-
+ vulkan/include/vulkan/vk_debug_report_lunarg.h | 16 +-
+ vulkan/include/vulkan/vk_platform.h | 34 +-
+ vulkan/include/vulkan/vulkan.h | 676 ++++++++++++-----------
+ vulkan/libvulkan/entry.cpp | 296 +++++-----
+ vulkan/libvulkan/entry.cpp.tmpl | 4 +-
+ vulkan/libvulkan/loader.cpp | 41 +-
+ vulkan/libvulkan/loader.h | 73 +--
+ vulkan/libvulkan/swapchain.cpp | 11 +
+ vulkan/nulldrv/null_driver.cpp | 4 +
+ vulkan/nulldrv/null_driver.h | 278 +++++-----
+ 12 files changed, 764 insertions(+), 695 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 3966f87..c77a148 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 203
++define VERSION_MINOR 204
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -2110,6 +2110,7 @@ class VkPhysicalDeviceLimits {
+ u32 maxPerStageDescriptorStorageBuffers /// max num of storage buffers allowed per-stage in a descriptor set
+ u32 maxPerStageDescriptorSampledImages /// max num of sampled images allowed per-stage in a descriptor set
+ u32 maxPerStageDescriptorStorageImages /// max num of storage images allowed per-stage in a descriptor set
++ u32 maxPerStageDescriptorInputAttachments
+ u32 maxDescriptorSetSamplers /// max num of samplers allowed in all stages in a descriptor set
+ u32 maxDescriptorSetUniformBuffers /// max num of uniform buffers allowed in all stages in a descriptor set
+ u32 maxDescriptorSetUniformBuffersDynamic /// max num of dynamic uniform buffers allowed in all stages in a descriptor set
+@@ -2117,6 +2118,7 @@ class VkPhysicalDeviceLimits {
+ u32 maxDescriptorSetStorageBuffersDynamic /// max num of dynamic storage buffers allowed in all stages in a descriptor set
+ u32 maxDescriptorSetSampledImages /// max num of sampled images allowed in all stages in a descriptor set
+ u32 maxDescriptorSetStorageImages /// max num of storage images allowed in all stages in a descriptor set
++ u32 maxDescriptorSetInputAttachments
+ /// vertex stage limits
+ u32 maxVertexInputAttributes /// max num of vertex input attribute slots
+ u32 maxVertexInputBindings /// max num of vertex input binding slots
+@@ -2318,7 +2320,7 @@ class VkPresentInfoKHR {
+ u32 swapchainCount
+ const VkSwapchainKHR* pSwapchains
+ const u32* imageIndices
+- const VkResult* pResults
++ VkResult* pResults
+ }
+
+ @extension("VK_KHR_display")
+diff --git a/vulkan/include/vulkan/vk_android_native_buffer.h b/vulkan/include/vulkan/vk_android_native_buffer.h
+index f1f2676..bf4641e 100644
+--- a/vulkan/include/vulkan/vk_android_native_buffer.h
++++ b/vulkan/include/vulkan/vk_android_native_buffer.h
+@@ -47,39 +47,39 @@ typedef struct {
+ int usage;
+ } VkNativeBufferANDROID;
+
+-typedef VkResult (VKAPI *PFN_vkGetSwapchainGrallocUsageANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
+-typedef VkResult (VKAPI *PFN_vkAcquireImageANDROID)(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore);
+-typedef VkResult (VKAPI *PFN_vkQueueSignalReleaseImageANDROID)(VkQueue queue, VkImage image, int* pNativeFenceFd);
++typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsageANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
++typedef VkResult (VKAPI_PTR *PFN_vkAcquireImageANDROID)(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore);
++typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageANDROID)(VkQueue queue, VkImage image, int* pNativeFenceFd);
+ // -- DEPRECATED --
+-typedef VkResult (VKAPI *PFN_vkImportNativeFenceANDROID)(VkDevice device, VkSemaphore semaphore, int nativeFenceFd);
+-typedef VkResult (VKAPI *PFN_vkQueueSignalNativeFenceANDROID)(VkQueue queue, int* pNativeFenceFd);
++typedef VkResult (VKAPI_PTR *PFN_vkImportNativeFenceANDROID)(VkDevice device, VkSemaphore semaphore, int nativeFenceFd);
++typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalNativeFenceANDROID)(VkQueue queue, int* pNativeFenceFd);
+ // ----------------
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkGetSwapchainGrallocUsageANDROID(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsageANDROID(
+ VkDevice device,
+ VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage
+ );
+-VkResult VKAPI vkAcquireImageANDROID(
++VKAPI_ATTR VkResult VKAPI_CALL vkAcquireImageANDROID(
+ VkDevice device,
+ VkImage image,
+ int nativeFenceFd,
+ VkSemaphore semaphore
+ );
+-VkResult VKAPI vkQueueSignalReleaseImageANDROID(
++VKAPI_ATTR VkResult VKAPI_CALL vkQueueSignalReleaseImageANDROID(
+ VkQueue queue,
+ VkImage image,
+ int* pNativeFenceFd
+ );
+ // -- DEPRECATED --
+-VkResult VKAPI vkImportNativeFenceANDROID(
++VKAPI_ATTR VkResult VKAPI_CALL vkImportNativeFenceANDROID(
+ VkDevice device,
+ VkSemaphore semaphore,
+ int nativeFenceFd
+ );
+-VkResult VKAPI vkQueueSignalNativeFenceANDROID(
++VKAPI_ATTR VkResult VKAPI_CALL vkQueueSignalNativeFenceANDROID(
+ VkQueue queue,
+ int* pNativeFenceFd
+ );
+diff --git a/vulkan/include/vulkan/vk_debug_report_lunarg.h b/vulkan/include/vulkan/vk_debug_report_lunarg.h
+index 286c354..58939c9 100644
+--- a/vulkan/include/vulkan/vk_debug_report_lunarg.h
++++ b/vulkan/include/vulkan/vk_debug_report_lunarg.h
+@@ -112,7 +112,7 @@ typedef enum _DEBUG_REPORT_ERROR
+ // ------------------------------------------------------------------------------------------------
+ // Vulkan function pointers
+
+-typedef VkBool32 (*PFN_vkDbgMsgCallback)(
++typedef VkBool32 (VKAPI_PTR *PFN_vkDbgMsgCallback)(
+ VkFlags msgFlags,
+ VkDbgObjectType objType,
+ uint64_t srcObject,
+@@ -125,25 +125,25 @@ typedef VkBool32 (*PFN_vkDbgMsgCallback)(
+ // ------------------------------------------------------------------------------------------------
+ // API functions
+
+-typedef VkResult (VKAPI *PFN_vkDbgCreateMsgCallback)(VkInstance instance, VkFlags msgFlags, const PFN_vkDbgMsgCallback pfnMsgCallback, void* pUserData, VkDbgMsgCallback* pMsgCallback);
+-typedef VkResult (VKAPI *PFN_vkDbgDestroyMsgCallback)(VkInstance instance, VkDbgMsgCallback msgCallback);
++typedef VkResult (VKAPI_PTR *PFN_vkDbgCreateMsgCallback)(VkInstance instance, VkFlags msgFlags, const PFN_vkDbgMsgCallback pfnMsgCallback, void* pUserData, VkDbgMsgCallback* pMsgCallback);
++typedef VkResult (VKAPI_PTR *PFN_vkDbgDestroyMsgCallback)(VkInstance instance, VkDbgMsgCallback msgCallback);
+
+ #ifdef VK_PROTOTYPES
+
+ // DebugReport extension entrypoints
+-VkResult VKAPI vkDbgCreateMsgCallback(
++VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
+ VkInstance instance,
+ VkFlags msgFlags,
+ const PFN_vkDbgMsgCallback pfnMsgCallback,
+ void* pUserData,
+ VkDbgMsgCallback* pMsgCallback);
+
+-VkResult VKAPI vkDbgDestroyMsgCallback(
++VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
+ VkInstance instance,
+ VkDbgMsgCallback msgCallback);
+
+ // DebugReport utility callback functions
+-void VKAPI vkDbgStringCallback(
++VKAPI_ATTR void VKAPI_CALL vkDbgStringCallback(
+ VkFlags msgFlags,
+ VkDbgObjectType objType,
+ uint64_t srcObject,
+@@ -153,7 +153,7 @@ void VKAPI vkDbgStringCallback(
+ const char* pMsg,
+ void* pUserData);
+
+-void VKAPI vkDbgStdioCallback(
++VKAPI_ATTR void VKAPI_CALL vkDbgStdioCallback(
+ VkFlags msgFlags,
+ VkDbgObjectType objType,
+ uint64_t srcObject,
+@@ -163,7 +163,7 @@ void VKAPI vkDbgStdioCallback(
+ const char* pMsg,
+ void* pUserData);
+
+-void VKAPI vkDbgBreakCallback(
++VKAPI_ATTR void VKAPI_CALL vkDbgBreakCallback(
+ VkFlags msgFlags,
+ VkDbgObjectType objType,
+ uint64_t srcObject,
+diff --git a/vulkan/include/vulkan/vk_platform.h b/vulkan/include/vulkan/vk_platform.h
+index 4bc6a86..a53e725 100644
+--- a/vulkan/include/vulkan/vk_platform.h
++++ b/vulkan/include/vulkan/vk_platform.h
+@@ -39,12 +39,40 @@ extern "C"
+ ***************************************************************************************************
+ */
+
++/* Platform-specific calling convention macros.
++ *
++ * Platforms should define these so that Vulkan clients call Vulkan commands
++ * with the same calling conventions that the Vulkan implementation expects.
++ *
++ * VKAPI_ATTR - Placed before the return type in function declarations.
++ * Useful for C++11 and GCC/Clang-style function attribute syntax.
++ * VKAPI_CALL - Placed after the return type in function declarations.
++ * Useful for MSVC-style calling convention syntax.
++ * VKAPI_PTR - Placed between the '(' and '*' in function pointer types.
++ *
++ * Function declaration: VKAPI_ATTR void VKAPI_CALL vkCommand(void);
++ * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
++ */
+ #if defined(_WIN32)
+- // On Windows, VKAPI should equate to the __stdcall convention
+- #define VKAPI __stdcall
++ // On Windows, Vulkan commands use the stdcall convention
++ #define VKAPI_ATTR
++ #define VKAPI_CALL __stdcall
++ #define VKAPI_PTR VKAPI_CALL
++#elif defined(__ANDROID__) && defined(__ARM_EABI__) && !defined(__ARM_ARCH_7A__)
++ // Android does not support Vulkan in native code using the "armeabi" ABI.
++ #error "Vulkan requires the 'armeabi-v7a' or 'armeabi-v7a-hard' ABI on 32-bit ARM CPUs"
++#elif defined(__ANDROID__) && defined(__ARM_ARCH_7A__)
++ // On Android/ARMv7a, Vulkan functions use the armeabi-v7a-hard calling
++ // convention, even if the application's native code is compiled with the
++ // armeabi-v7a calling convention.
++ #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
++ #define VKAPI_CALL
++ #define VKAPI_PTR VKAPI_ATTR
+ #else
+ // On other platforms, use the default calling convention
+- #define VKAPI
++ #define VKAPI_ATTR
++ #define VKAPI_CALL
++ #define VKAPI_PTR
+ #endif
+
+ #include <stddef.h>
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 21bb796..2791b8a 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 203, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 204, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -1046,36 +1046,36 @@ typedef enum VkQueryControlFlagBits {
+ } VkQueryControlFlagBits;
+ typedef VkFlags VkQueryControlFlags;
+
+-typedef void* (VKAPI *PFN_vkAllocationFunction)(
++typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
+ void* pUserData,
+ size_t size,
+ size_t alignment,
+ VkSystemAllocationScope allocationScope);
+
+-typedef void* (VKAPI *PFN_vkReallocationFunction)(
++typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
+ void* pUserData,
+ void* pOriginal,
+ size_t size,
+ size_t alignment,
+ VkSystemAllocationScope allocationScope);
+
+-typedef void (VKAPI *PFN_vkFreeFunction)(
++typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
+ void* pUserData,
+ void* pMemory);
+
+-typedef void (VKAPI *PFN_vkInternalAllocationNotification)(
++typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
+ void* pUserData,
+ size_t size,
+ VkInternalAllocationType allocationType,
+ VkSystemAllocationScope allocationScope);
+
+-typedef void (VKAPI *PFN_vkInternalFreeNotification)(
++typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
+ void* pUserData,
+ size_t size,
+ VkInternalAllocationType allocationType,
+ VkSystemAllocationScope allocationScope);
+
+-typedef void (VKAPI *PFN_vkVoidFunction)(void);
++typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
+
+ typedef struct VkApplicationInfo {
+ VkStructureType sType;
+@@ -1203,6 +1203,7 @@ typedef struct VkPhysicalDeviceLimits {
+ uint32_t maxPerStageDescriptorStorageBuffers;
+ uint32_t maxPerStageDescriptorSampledImages;
+ uint32_t maxPerStageDescriptorStorageImages;
++ uint32_t maxPerStageDescriptorInputAttachments;
+ uint32_t maxDescriptorSetSamplers;
+ uint32_t maxDescriptorSetUniformBuffers;
+ uint32_t maxDescriptorSetUniformBuffersDynamic;
+@@ -1210,6 +1211,7 @@ typedef struct VkPhysicalDeviceLimits {
+ uint32_t maxDescriptorSetStorageBuffersDynamic;
+ uint32_t maxDescriptorSetSampledImages;
+ uint32_t maxDescriptorSetStorageImages;
++ uint32_t maxDescriptorSetInputAttachments;
+ uint32_t maxVertexInputAttributes;
+ uint32_t maxVertexInputBindings;
+ uint32_t maxVertexInputAttributeOffset;
+@@ -2136,169 +2138,169 @@ typedef struct VkMemoryBarrier {
+ } VkMemoryBarrier;
+
+
+-typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
+-typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+-typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+-typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+-typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+-typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+-typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+-typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
+-typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
+-typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
+-typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+-typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+-typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+-typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+-typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+-typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
+-typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
+-typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
+-typedef VkResult (VKAPI *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
+-typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
+-typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
+-typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
+-typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
+-typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+-typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+-typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+-typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+-typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+-typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+-typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
+-typedef VkResult (VKAPI *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
+-typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+-typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
+-typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
+-typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
+-typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
+-typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
+-typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
+-typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
+-typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
+-typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
+-typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+-typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
+-typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
+-typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
+-typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
+-typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+-typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
+-typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
+-typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
+-typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+-typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+-typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+-typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+-typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
+-typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
+-typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
+-typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
+-typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+-typedef VkResult (VKAPI *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
+-typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
+-typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+-typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
+-typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+-typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
+-typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+-typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
+-typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
+-typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
+-typedef VkResult (VKAPI *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
+-typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
+-typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+-typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
+-typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
+-typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+-typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);
+-typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
+-typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
+-typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
+-typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
+-typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
+-typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
+-typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
+-typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
+-typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+-typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+-typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+-typedef void (VKAPI *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+-typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+-typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+-typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+-typedef void (VKAPI *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
+-typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
+-typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+-typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+-typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+-typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+-typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+-typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData);
+-typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
+-typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+-typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+-typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+-typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+-typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
+-typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
+-typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags);
+-typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry);
+-typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+-typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry);
+-typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+-typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values);
+-typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
+-typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
+-typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
+-typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
++typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
++typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
++typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
++typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
++typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
++typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
++typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
++typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
++typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
++typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
++typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
++typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
++typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
++typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
++typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
++typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
++typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
++typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
++typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
++typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
++typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
++typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
++typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
++typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
++typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
++typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
++typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
++typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
++typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
++typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
++typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
++typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
++typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
++typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
++typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
++typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
++typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
++typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
++typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
++typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
++typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
++typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
++typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
++typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
++typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
++typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
++typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
++typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
++typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
++typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
++typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
++typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
++typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
++typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
++typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
++typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
++typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
++typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
++typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
++typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
++typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
++typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
++typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
++typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
++typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
++typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);
++typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
++typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
++typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
++typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
++typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
++typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
++typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
++typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
++typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
++typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
++typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
++typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
++typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
++typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
++typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
++typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
++typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
++typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
++typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
++typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
++typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
++typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
++typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData);
++typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
++typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
++typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
++typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
++typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
++typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
++typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
++typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
++typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
++typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags);
++typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry);
++typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
++typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry);
++typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
++typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values);
++typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
++typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
++typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
++typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers);
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkCreateInstance(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance);
+
+-void VKAPI vkDestroyInstance(
++VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
+ VkInstance instance,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkEnumeratePhysicalDevices(
++VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices);
+
+-void VKAPI vkGetPhysicalDeviceFeatures(
++VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures);
+
+-void VKAPI vkGetPhysicalDeviceFormatProperties(
++VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties);
+
+-VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+@@ -2307,87 +2309,87 @@ VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties);
+
+-void VKAPI vkGetPhysicalDeviceProperties(
++VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties);
+
+-void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
++VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties);
+
+-void VKAPI vkGetPhysicalDeviceMemoryProperties(
++VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+
+-PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(
++VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
+ VkInstance instance,
+ const char* pName);
+
+-PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
++VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
+ VkDevice device,
+ const char* pName);
+
+-VkResult VKAPI vkCreateDevice(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice);
+
+-void VKAPI vkDestroyDevice(
++VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
+ VkDevice device,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkEnumerateInstanceExtensionProperties(
++VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+
+-VkResult VKAPI vkEnumerateDeviceExtensionProperties(
++VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties);
+
+-VkResult VKAPI vkEnumerateInstanceLayerProperties(
++VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+
+-VkResult VKAPI vkEnumerateDeviceLayerProperties(
++VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties);
+
+-void VKAPI vkGetDeviceQueue(
++VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue);
+
+-VkResult VKAPI vkQueueSubmit(
++VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
+ VkQueue queue,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
+ VkFence fence);
+
+-VkResult VKAPI vkQueueWaitIdle(
++VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
+ VkQueue queue);
+
+-VkResult VKAPI vkDeviceWaitIdle(
++VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
+ VkDevice device);
+
+-VkResult VKAPI vkAllocateMemory(
++VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory);
+
+-void VKAPI vkFreeMemory(
++VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkMapMemory(
++VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+@@ -2395,54 +2397,54 @@ VkResult VKAPI vkMapMemory(
+ VkMemoryMapFlags flags,
+ void** ppData);
+
+-void VKAPI vkUnmapMemory(
++VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
+ VkDevice device,
+ VkDeviceMemory memory);
+
+-VkResult VKAPI vkFlushMappedMemoryRanges(
++VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
+
+-VkResult VKAPI vkInvalidateMappedMemoryRanges(
++VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
+
+-void VKAPI vkGetDeviceMemoryCommitment(
++VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes);
+
+-VkResult VKAPI vkBindBufferMemory(
++VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
+ VkDevice device,
+ VkBuffer buffer,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
+
+-VkResult VKAPI vkBindImageMemory(
++VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
+ VkDevice device,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
+
+-void VKAPI vkGetBufferMemoryRequirements(
++VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements);
+
+-void VKAPI vkGetImageMemoryRequirements(
++VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements);
+
+-void VKAPI vkGetImageSparseMemoryRequirements(
++VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+
+-void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
++VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+@@ -2452,85 +2454,85 @@ void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties);
+
+-VkResult VKAPI vkQueueBindSparse(
++VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
+ VkQueue queue,
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence);
+
+-VkResult VKAPI vkCreateFence(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence);
+
+-void VKAPI vkDestroyFence(
++VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
+ VkDevice device,
+ VkFence fence,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkResetFences(
++VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences);
+
+-VkResult VKAPI vkGetFenceStatus(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
+ VkDevice device,
+ VkFence fence);
+
+-VkResult VKAPI vkWaitForFences(
++VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences,
+ VkBool32 waitAll,
+ uint64_t timeout);
+
+-VkResult VKAPI vkCreateSemaphore(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore);
+
+-void VKAPI vkDestroySemaphore(
++VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkCreateEvent(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent);
+
+-void VKAPI vkDestroyEvent(
++VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
+ VkDevice device,
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkGetEventStatus(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
+ VkDevice device,
+ VkEvent event);
+
+-VkResult VKAPI vkSetEvent(
++VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
+ VkDevice device,
+ VkEvent event);
+
+-VkResult VKAPI vkResetEvent(
++VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
+ VkDevice device,
+ VkEvent event);
+
+-VkResult VKAPI vkCreateQueryPool(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool);
+
+-void VKAPI vkDestroyQueryPool(
++VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
+ VkDevice device,
+ VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkGetQueryPoolResults(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
+ VkDevice device,
+ VkQueryPool queryPool,
+ uint32_t startQuery,
+@@ -2540,91 +2542,91 @@ VkResult VKAPI vkGetQueryPoolResults(
+ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+
+-VkResult VKAPI vkCreateBuffer(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer);
+
+-void VKAPI vkDestroyBuffer(
++VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
+ VkDevice device,
+ VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkCreateBufferView(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView);
+
+-void VKAPI vkDestroyBufferView(
++VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
+ VkDevice device,
+ VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkCreateImage(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage);
+
+-void VKAPI vkDestroyImage(
++VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
+ VkDevice device,
+ VkImage image,
+ const VkAllocationCallbacks* pAllocator);
+
+-void VKAPI vkGetImageSubresourceLayout(
++VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout);
+
+-VkResult VKAPI vkCreateImageView(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView);
+
+-void VKAPI vkDestroyImageView(
++VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
+ VkDevice device,
+ VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkCreateShaderModule(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule);
+
+-void VKAPI vkDestroyShaderModule(
++VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
+ VkDevice device,
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkCreatePipelineCache(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache);
+
+-void VKAPI vkDestroyPipelineCache(
++VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkGetPipelineCacheData(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ size_t* pDataSize,
+ void* pData);
+
+-VkResult VKAPI vkMergePipelineCaches(
++VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
+ VkDevice device,
+ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches);
+
+-VkResult VKAPI vkCreateGraphicsPipelines(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+@@ -2632,7 +2634,7 @@ VkResult VKAPI vkCreateGraphicsPipelines(
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+
+-VkResult VKAPI vkCreateComputePipelines(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+@@ -2640,193 +2642,193 @@ VkResult VKAPI vkCreateComputePipelines(
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines);
+
+-void VKAPI vkDestroyPipeline(
++VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
+ VkDevice device,
+ VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkCreatePipelineLayout(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout);
+
+-void VKAPI vkDestroyPipelineLayout(
++VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkCreateSampler(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler);
+
+-void VKAPI vkDestroySampler(
++VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
+ VkDevice device,
+ VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkCreateDescriptorSetLayout(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout);
+
+-void VKAPI vkDestroyDescriptorSetLayout(
++VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkCreateDescriptorPool(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool);
+
+-void VKAPI vkDestroyDescriptorPool(
++VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkResetDescriptorPool(
++VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags);
+
+-VkResult VKAPI vkAllocateDescriptorSets(
++VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
+ VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets);
+
+-VkResult VKAPI vkFreeDescriptorSets(
++VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets);
+
+-void VKAPI vkUpdateDescriptorSets(
++VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
+ VkDevice device,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies);
+
+-VkResult VKAPI vkCreateFramebuffer(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer);
+
+-void VKAPI vkDestroyFramebuffer(
++VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
+ VkDevice device,
+ VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkCreateRenderPass(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass);
+
+-void VKAPI vkDestroyRenderPass(
++VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator);
+
+-void VKAPI vkGetRenderAreaGranularity(
++VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity);
+
+-VkResult VKAPI vkCreateCommandPool(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
+ VkDevice device,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool);
+
+-void VKAPI vkDestroyCommandPool(
++VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator);
+
+-VkResult VKAPI vkResetCommandPool(
++VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags);
+
+-VkResult VKAPI vkAllocateCommandBuffers(
++VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers);
+
+-void VKAPI vkFreeCommandBuffers(
++VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
+ VkDevice device,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers);
+
+-VkResult VKAPI vkBeginCommandBuffer(
++VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo);
+
+-VkResult VKAPI vkEndCommandBuffer(
++VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
+ VkCommandBuffer commandBuffer);
+
+-VkResult VKAPI vkResetCommandBuffer(
++VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags);
+
+-void VKAPI vkCmdBindPipeline(
++VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline);
+
+-void VKAPI vkCmdSetViewport(
++VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
+ VkCommandBuffer commandBuffer,
+ uint32_t viewportCount,
+ const VkViewport* pViewports);
+
+-void VKAPI vkCmdSetScissor(
++VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
+ VkCommandBuffer commandBuffer,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors);
+
+-void VKAPI vkCmdSetLineWidth(
++VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
+ VkCommandBuffer commandBuffer,
+ float lineWidth);
+
+-void VKAPI vkCmdSetDepthBias(
++VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
+ VkCommandBuffer commandBuffer,
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor);
+
+-void VKAPI vkCmdSetBlendConstants(
++VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
+ VkCommandBuffer commandBuffer,
+ const float blendConstants[4]);
+
+-void VKAPI vkCmdSetDepthBounds(
++VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
+ VkCommandBuffer commandBuffer,
+ float minDepthBounds,
+ float maxDepthBounds);
+
+-void VKAPI vkCmdSetStencilCompareMask(
++VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t compareMask);
+
+-void VKAPI vkCmdSetStencilWriteMask(
++VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t writeMask);
+
+-void VKAPI vkCmdSetStencilReference(
++VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t reference);
+
+-void VKAPI vkCmdBindDescriptorSets(
++VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+@@ -2836,27 +2838,27 @@ void VKAPI vkCmdBindDescriptorSets(
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets);
+
+-void VKAPI vkCmdBindIndexBuffer(
++VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType);
+
+-void VKAPI vkCmdBindVertexBuffers(
++VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
+ VkCommandBuffer commandBuffer,
+ uint32_t startBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets);
+
+-void VKAPI vkCmdDraw(
++VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
+ VkCommandBuffer commandBuffer,
+ uint32_t vertexCount,
+ uint32_t instanceCount,
+ uint32_t firstVertex,
+ uint32_t firstInstance);
+
+-void VKAPI vkCmdDrawIndexed(
++VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
+ VkCommandBuffer commandBuffer,
+ uint32_t indexCount,
+ uint32_t instanceCount,
+@@ -2864,39 +2866,39 @@ void VKAPI vkCmdDrawIndexed(
+ int32_t vertexOffset,
+ uint32_t firstInstance);
+
+-void VKAPI vkCmdDrawIndirect(
++VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+
+-void VKAPI vkCmdDrawIndexedIndirect(
++VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride);
+
+-void VKAPI vkCmdDispatch(
++VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
+ VkCommandBuffer commandBuffer,
+ uint32_t x,
+ uint32_t y,
+ uint32_t z);
+
+-void VKAPI vkCmdDispatchIndirect(
++VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset);
+
+-void VKAPI vkCmdCopyBuffer(
++VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions);
+
+-void VKAPI vkCmdCopyImage(
++VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+@@ -2905,7 +2907,7 @@ void VKAPI vkCmdCopyImage(
+ uint32_t regionCount,
+ const VkImageCopy* pRegions);
+
+-void VKAPI vkCmdBlitImage(
++VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+@@ -2915,7 +2917,7 @@ void VKAPI vkCmdBlitImage(
+ const VkImageBlit* pRegions,
+ VkFilter filter);
+
+-void VKAPI vkCmdCopyBufferToImage(
++VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+@@ -2923,7 +2925,7 @@ void VKAPI vkCmdCopyBufferToImage(
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+
+-void VKAPI vkCmdCopyImageToBuffer(
++VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+@@ -2931,21 +2933,21 @@ void VKAPI vkCmdCopyImageToBuffer(
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions);
+
+-void VKAPI vkCmdUpdateBuffer(
++VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const uint32_t* pData);
+
+-void VKAPI vkCmdFillBuffer(
++VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data);
+
+-void VKAPI vkCmdClearColorImage(
++VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+@@ -2953,7 +2955,7 @@ void VKAPI vkCmdClearColorImage(
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges);
+
+-void VKAPI vkCmdClearDepthStencilImage(
++VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+@@ -2961,14 +2963,14 @@ void VKAPI vkCmdClearDepthStencilImage(
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges);
+
+-void VKAPI vkCmdClearAttachments(
++VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
+ VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkClearRect* pRects);
+
+-void VKAPI vkCmdResolveImage(
++VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+@@ -2977,17 +2979,17 @@ void VKAPI vkCmdResolveImage(
+ uint32_t regionCount,
+ const VkImageResolve* pRegions);
+
+-void VKAPI vkCmdSetEvent(
++VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+
+-void VKAPI vkCmdResetEvent(
++VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask);
+
+-void VKAPI vkCmdWaitEvents(
++VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
+ VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent* pEvents,
+@@ -2996,7 +2998,7 @@ void VKAPI vkCmdWaitEvents(
+ uint32_t memoryBarrierCount,
+ const void* const* ppMemoryBarriers);
+
+-void VKAPI vkCmdPipelineBarrier(
++VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+@@ -3004,30 +3006,30 @@ void VKAPI vkCmdPipelineBarrier(
+ uint32_t memoryBarrierCount,
+ const void* const* ppMemoryBarriers);
+
+-void VKAPI vkCmdBeginQuery(
++VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t entry,
+ VkQueryControlFlags flags);
+
+-void VKAPI vkCmdEndQuery(
++VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t entry);
+
+-void VKAPI vkCmdResetQueryPool(
++VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t startQuery,
+ uint32_t queryCount);
+
+-void VKAPI vkCmdWriteTimestamp(
++VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t entry);
+
+-void VKAPI vkCmdCopyQueryPoolResults(
++VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t startQuery,
+@@ -3037,7 +3039,7 @@ void VKAPI vkCmdCopyQueryPoolResults(
+ VkDeviceSize stride,
+ VkQueryResultFlags flags);
+
+-void VKAPI vkCmdPushConstants(
++VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
+ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+@@ -3045,19 +3047,19 @@ void VKAPI vkCmdPushConstants(
+ uint32_t size,
+ const void* values);
+
+-void VKAPI vkCmdBeginRenderPass(
++VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents);
+
+-void VKAPI vkCmdNextSubpass(
++VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
+ VkCommandBuffer commandBuffer,
+ VkSubpassContents contents);
+
+-void VKAPI vkCmdEndRenderPass(
++VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
+ VkCommandBuffer commandBuffer);
+
+-void VKAPI vkCmdExecuteCommands(
++VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBuffersCount,
+ const VkCommandBuffer* pCommandBuffers);
+@@ -3148,35 +3150,35 @@ typedef struct VkSurfaceFormatKHR {
+ } VkSurfaceFormatKHR;
+
+
+-typedef void (VKAPI *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
++typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface);
++typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
++typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
++typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
++typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
+
+ #ifdef VK_PROTOTYPES
+-void VKAPI vkDestroySurfaceKHR(
++VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
+ VkInstance instance,
+ VkSurfaceKHR surface);
+
+-VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported);
+
+-VkResult VKAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+
+-VkResult VKAPI vkGetPhysicalDeviceSurfaceFormatsKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats);
+
+-VkResult VKAPI vkGetPhysicalDeviceSurfacePresentModesKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+@@ -3227,29 +3229,29 @@ typedef struct VkPresentInfoKHR {
+ } VkPresentInfoKHR;
+
+
+-typedef VkResult (VKAPI *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain);
+-typedef void (VKAPI *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain);
+-typedef VkResult (VKAPI *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
+-typedef VkResult (VKAPI *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
+-typedef VkResult (VKAPI *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain);
++typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain);
++typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
++typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
++typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo);
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkCreateSwapchainKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ VkSwapchainKHR* pSwapchain);
+
+-void VKAPI vkDestroySwapchainKHR(
++VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain);
+
+-VkResult VKAPI vkGetSwapchainImagesKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages);
+
+-VkResult VKAPI vkAcquireNextImageKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint64_t timeout,
+@@ -3257,7 +3259,7 @@ VkResult VKAPI vkAcquireNextImageKHR(
+ VkFence fence,
+ uint32_t* pImageIndex);
+
+-VkResult VKAPI vkQueuePresentKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
+ VkQueue queue,
+ VkPresentInfoKHR* pPresentInfo);
+ #endif
+@@ -3336,49 +3338,49 @@ typedef struct VkDisplaySurfaceCreateInfoKHR {
+ } VkDisplaySurfaceCreateInfoKHR;
+
+
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
+-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
+-typedef VkResult (VKAPI *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayKHR* pProperties);
+-typedef VkResult (VKAPI *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
+-typedef VkResult (VKAPI *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, VkDisplayModeKHR* pMode);
+-typedef VkResult (VKAPI *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeCreateInfoKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+-typedef VkResult (VKAPI *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, VkSurfaceKHR* pSurface);
++typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
++typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
++typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayKHR* pProperties);
++typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, VkDisplayModeKHR* pMode);
++typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeCreateInfoKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, VkSurfaceKHR* pSurface);
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkGetPhysicalDeviceDisplayPropertiesKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties);
+
+-VkResult VKAPI vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties);
+
+-VkResult VKAPI vkGetDisplayPlaneSupportedDisplaysKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayKHR* pProperties);
+
+-VkResult VKAPI vkGetDisplayModePropertiesKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties);
+
+-VkResult VKAPI vkCreateDisplayModeKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ VkDisplayModeKHR* pMode);
+
+-VkResult VKAPI vkGetDisplayPlaneCapabilitiesKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayModeCreateInfoKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+
+-VkResult VKAPI vkCreateDisplayPlaneSurfaceKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ VkSurfaceKHR* pSurface);
+@@ -3416,17 +3418,17 @@ typedef struct VkDisplayPresentInfoKHR {
+ #define VK_KHR_XLIB_SURFACE_EXTENSION_NUMBER 5
+ #define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
+
+-typedef VkResult (VKAPI *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, VkSurfaceKHR* pSurface);
+-typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, VkSurfaceKHR* pSurface);
++typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkCreateXlibSurfaceKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
+ VkInstance instance,
+ Display* dpy,
+ Window window,
+ VkSurfaceKHR* pSurface);
+
+-VkBool32 VKAPI vkGetPhysicalDeviceXlibPresentationSupportKHR(
++VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display* dpy,
+@@ -3442,17 +3444,17 @@ VkBool32 VKAPI vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ #define VK_KHR_XCB_SURFACE_EXTENSION_NUMBER 6
+ #define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
+
+-typedef VkResult (VKAPI *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, xcb_connection_t* connection, xcb_window_t window, VkSurfaceKHR* pSurface);
+-typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, xcb_connection_t* connection, xcb_window_t window, VkSurfaceKHR* pSurface);
++typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkCreateXcbSurfaceKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
+ VkInstance instance,
+ xcb_connection_t* connection,
+ xcb_window_t window,
+ VkSurfaceKHR* pSurface);
+
+-VkBool32 VKAPI vkGetPhysicalDeviceXcbPresentationSupportKHR(
++VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+@@ -3468,17 +3470,17 @@ VkBool32 VKAPI vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ #define VK_KHR_WAYLAND_SURFACE_EXTENSION_NUMBER 7
+ #define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
+
+-typedef VkResult (VKAPI *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, struct wl_display* display, struct wl_surface* surface, VkSurfaceKHR* pSurface);
+-typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, struct wl_display* display, struct wl_surface* surface, VkSurfaceKHR* pSurface);
++typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkCreateWaylandSurfaceKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
+ VkInstance instance,
+ struct wl_display* display,
+ struct wl_surface* surface,
+ VkSurfaceKHR* pSurface);
+
+-VkBool32 VKAPI vkGetPhysicalDeviceWaylandPresentationSupportKHR(
++VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ struct wl_display* display);
+@@ -3493,17 +3495,17 @@ VkBool32 VKAPI vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ #define VK_KHR_MIR_SURFACE_EXTENSION_NUMBER 8
+ #define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
+
+-typedef VkResult (VKAPI *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, MirConnection* connection, MirSurface* mirSurface, VkSurfaceKHR* pSurface);
+-typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, MirConnection* connection, MirSurface* mirSurface, VkSurfaceKHR* pSurface);
++typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkCreateMirSurfaceKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
+ VkInstance instance,
+ MirConnection* connection,
+ MirSurface* mirSurface,
+ VkSurfaceKHR* pSurface);
+
+-VkBool32 VKAPI vkGetPhysicalDeviceMirPresentationSupportKHR(
++VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ MirConnection* connection);
+@@ -3520,10 +3522,10 @@ VkBool32 VKAPI vkGetPhysicalDeviceMirPresentationSupportKHR(
+ #define VK_ERROR_INVALID_ANDROID_WINDOW_KHR ((VkResult)(int)0xc0002400)
+ #define VK_ERROR_ANDROID_WINDOW_IN_USE_KHR ((VkResult)(int)0xc0002401)
+
+-typedef VkResult (VKAPI *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, ANativeWindow* window, VkSurfaceKHR* pSurface);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, ANativeWindow* window, VkSurfaceKHR* pSurface);
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkCreateAndroidSurfaceKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
+ VkInstance instance,
+ ANativeWindow* window,
+ VkSurfaceKHR* pSurface);
+@@ -3538,17 +3540,17 @@ VkResult VKAPI vkCreateAndroidSurfaceKHR(
+ #define VK_KHR_WIN32_SURFACE_EXTENSION_NUMBER 10
+ #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
+
+-typedef VkResult (VKAPI *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, HINSTANCE hinstance, HWND hwnd, VkSurfaceKHR* pSurface);
+-typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, HINSTANCE hinstance, HWND hwnd, VkSurfaceKHR* pSurface);
++typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
+
+ #ifdef VK_PROTOTYPES
+-VkResult VKAPI vkCreateWin32SurfaceKHR(
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
+ VkInstance instance,
+ HINSTANCE hinstance,
+ HWND hwnd,
+ VkSurfaceKHR* pSurface);
+
+-VkBool32 VKAPI vkGetPhysicalDeviceWin32PresentationSupportKHR(
++VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex);
+ #endif
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index fffb3eb..7b8db6b 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -42,741 +42,741 @@ namespace {
+ } // namespace
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
++VKAPI_ATTR VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
+ return vulkan::CreateInstance(pCreateInfo, pAllocator, pInstance);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(instance).DestroyInstance(instance, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
++VKAPI_ATTR VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
+ return GetVtbl(instance).EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+ }
+
+ __attribute__((visibility("default")))
+-PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) {
++VKAPI_ATTR PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) {
+ return vulkan::GetDeviceProcAddr(device, pName);
+ }
+
+ __attribute__((visibility("default")))
+-PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
++VKAPI_ATTR PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
+ return vulkan::GetInstanceProcAddr(instance, pName);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
++VKAPI_ATTR void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceProperties(physicalDevice, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
++VKAPI_ATTR void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
++VKAPI_ATTR void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
++VKAPI_ATTR void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
++VKAPI_ATTR void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
++VKAPI_ATTR VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+ return GetVtbl(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
++VKAPI_ATTR VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
+ return GetVtbl(physicalDevice).CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
+ vulkan::DestroyDevice(device, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
++VKAPI_ATTR VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+ return vulkan::EnumerateInstanceLayerProperties(pPropertyCount, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
++VKAPI_ATTR VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+ return vulkan::EnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
++VKAPI_ATTR VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+ return GetVtbl(physicalDevice).EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
++VKAPI_ATTR VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+ return GetVtbl(physicalDevice).EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
++VKAPI_ATTR void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
+ vulkan::GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
++VKAPI_ATTR VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
+ return GetVtbl(queue).QueueSubmit(queue, submitCount, pSubmits, fence);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkQueueWaitIdle(VkQueue queue) {
++VKAPI_ATTR VkResult vkQueueWaitIdle(VkQueue queue) {
+ return GetVtbl(queue).QueueWaitIdle(queue);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkDeviceWaitIdle(VkDevice device) {
++VKAPI_ATTR VkResult vkDeviceWaitIdle(VkDevice device) {
+ return GetVtbl(device).DeviceWaitIdle(device);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
++VKAPI_ATTR VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
+ return GetVtbl(device).AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+ }
+
+ __attribute__((visibility("default")))
+-void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).FreeMemory(device, memory, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
++VKAPI_ATTR VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
+ return GetVtbl(device).MapMemory(device, memory, offset, size, flags, ppData);
+ }
+
+ __attribute__((visibility("default")))
+-void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
++VKAPI_ATTR void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
+ GetVtbl(device).UnmapMemory(device, memory);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
++VKAPI_ATTR VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+ return GetVtbl(device).FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
++VKAPI_ATTR VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+ return GetVtbl(device).InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
++VKAPI_ATTR void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
+ GetVtbl(device).GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
++VKAPI_ATTR void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
+ GetVtbl(device).GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
++VKAPI_ATTR VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+ return GetVtbl(device).BindBufferMemory(device, buffer, memory, memoryOffset);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
++VKAPI_ATTR void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
+ GetVtbl(device).GetImageMemoryRequirements(device, image, pMemoryRequirements);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
++VKAPI_ATTR VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+ return GetVtbl(device).BindImageMemory(device, image, memory, memoryOffset);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
++VKAPI_ATTR void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+ GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
++VKAPI_ATTR void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
++VKAPI_ATTR VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
+ return GetVtbl(queue).QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
++VKAPI_ATTR VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+ return GetVtbl(device).CreateFence(device, pCreateInfo, pAllocator, pFence);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyFence(device, fence, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
++VKAPI_ATTR VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
+ return GetVtbl(device).ResetFences(device, fenceCount, pFences);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetFenceStatus(VkDevice device, VkFence fence) {
++VKAPI_ATTR VkResult vkGetFenceStatus(VkDevice device, VkFence fence) {
+ return GetVtbl(device).GetFenceStatus(device, fence);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
++VKAPI_ATTR VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
+ return GetVtbl(device).WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
++VKAPI_ATTR VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
+ return GetVtbl(device).CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroySemaphore(device, semaphore, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
++VKAPI_ATTR VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
+ return GetVtbl(device).CreateEvent(device, pCreateInfo, pAllocator, pEvent);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyEvent(device, event, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetEventStatus(VkDevice device, VkEvent event) {
++VKAPI_ATTR VkResult vkGetEventStatus(VkDevice device, VkEvent event) {
+ return GetVtbl(device).GetEventStatus(device, event);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkSetEvent(VkDevice device, VkEvent event) {
++VKAPI_ATTR VkResult vkSetEvent(VkDevice device, VkEvent event) {
+ return GetVtbl(device).SetEvent(device, event);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkResetEvent(VkDevice device, VkEvent event) {
++VKAPI_ATTR VkResult vkResetEvent(VkDevice device, VkEvent event) {
+ return GetVtbl(device).ResetEvent(device, event);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
++VKAPI_ATTR VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
+ return GetVtbl(device).CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyQueryPool(device, queryPool, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
++VKAPI_ATTR VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
+ return GetVtbl(device).GetQueryPoolResults(device, queryPool, startQuery, queryCount, dataSize, pData, stride, flags);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
++VKAPI_ATTR VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
+ return GetVtbl(device).CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyBuffer(device, buffer, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
++VKAPI_ATTR VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
+ return GetVtbl(device).CreateBufferView(device, pCreateInfo, pAllocator, pView);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyBufferView(device, bufferView, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
++VKAPI_ATTR VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
+ return GetVtbl(device).CreateImage(device, pCreateInfo, pAllocator, pImage);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyImage(device, image, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
++VKAPI_ATTR void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+ GetVtbl(device).GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
++VKAPI_ATTR VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
+ return GetVtbl(device).CreateImageView(device, pCreateInfo, pAllocator, pView);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyImageView(device, imageView, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
++VKAPI_ATTR VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
+ return GetVtbl(device).CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyShaderModule(device, shaderModule, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
++VKAPI_ATTR VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
+ return GetVtbl(device).CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyPipelineCache(device, pipelineCache, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
++VKAPI_ATTR VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
+ return GetVtbl(device).GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
++VKAPI_ATTR VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
+ return GetVtbl(device).MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
++VKAPI_ATTR VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+ return GetVtbl(device).CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
++VKAPI_ATTR VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+ return GetVtbl(device).CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyPipeline(device, pipeline, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
++VKAPI_ATTR VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
+ return GetVtbl(device).CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyPipelineLayout(device, pipelineLayout, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
++VKAPI_ATTR VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
+ return GetVtbl(device).CreateSampler(device, pCreateInfo, pAllocator, pSampler);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroySampler(device, sampler, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
++VKAPI_ATTR VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+ return GetVtbl(device).CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
++VKAPI_ATTR VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
+ return GetVtbl(device).CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyDescriptorPool(device, descriptorPool, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
++VKAPI_ATTR VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
+ return GetVtbl(device).ResetDescriptorPool(device, descriptorPool, flags);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
++VKAPI_ATTR VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
+ return GetVtbl(device).AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
++VKAPI_ATTR VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
+ return GetVtbl(device).FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+ }
+
+ __attribute__((visibility("default")))
+-void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
++VKAPI_ATTR void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
+ GetVtbl(device).UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
++VKAPI_ATTR VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
+ return GetVtbl(device).CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyFramebuffer(device, framebuffer, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
++VKAPI_ATTR VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+ return GetVtbl(device).CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyRenderPass(device, renderPass, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
++VKAPI_ATTR void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+ GetVtbl(device).GetRenderAreaGranularity(device, renderPass, pGranularity);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
++VKAPI_ATTR VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
+ return GetVtbl(device).CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
++VKAPI_ATTR void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyCommandPool(device, commandPool, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
++VKAPI_ATTR VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
+ return GetVtbl(device).ResetCommandPool(device, commandPool, flags);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
++VKAPI_ATTR VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
+ return GetVtbl(device).AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
+ }
+
+ __attribute__((visibility("default")))
+-void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
++VKAPI_ATTR void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
+ GetVtbl(device).FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
++VKAPI_ATTR VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
+ return GetVtbl(commandBuffer).BeginCommandBuffer(commandBuffer, pBeginInfo);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
++VKAPI_ATTR VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
+ return GetVtbl(commandBuffer).EndCommandBuffer(commandBuffer);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
++VKAPI_ATTR VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
+ return GetVtbl(commandBuffer).ResetCommandBuffer(commandBuffer, flags);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
++VKAPI_ATTR void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+ GetVtbl(commandBuffer).CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
++VKAPI_ATTR void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
+ GetVtbl(commandBuffer).CmdSetViewport(commandBuffer, viewportCount, pViewports);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
++VKAPI_ATTR void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
+ GetVtbl(commandBuffer).CmdSetScissor(commandBuffer, scissorCount, pScissors);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
++VKAPI_ATTR void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
+ GetVtbl(commandBuffer).CmdSetLineWidth(commandBuffer, lineWidth);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
++VKAPI_ATTR void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
+ GetVtbl(commandBuffer).CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
++VKAPI_ATTR void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
+ GetVtbl(commandBuffer).CmdSetBlendConstants(commandBuffer, blendConstants);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
++VKAPI_ATTR void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
+ GetVtbl(commandBuffer).CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
++VKAPI_ATTR void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
+ GetVtbl(commandBuffer).CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
++VKAPI_ATTR void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
+ GetVtbl(commandBuffer).CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
++VKAPI_ATTR void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
+ GetVtbl(commandBuffer).CmdSetStencilReference(commandBuffer, faceMask, reference);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
++VKAPI_ATTR void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+ GetVtbl(commandBuffer).CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
++VKAPI_ATTR void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
+ GetVtbl(commandBuffer).CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
++VKAPI_ATTR void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
+ GetVtbl(commandBuffer).CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
++VKAPI_ATTR void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+ GetVtbl(commandBuffer).CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
++VKAPI_ATTR void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+ GetVtbl(commandBuffer).CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
++VKAPI_ATTR void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ GetVtbl(commandBuffer).CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
++VKAPI_ATTR void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ GetVtbl(commandBuffer).CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
++VKAPI_ATTR void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
+ GetVtbl(commandBuffer).CmdDispatch(commandBuffer, x, y, z);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
++VKAPI_ATTR void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
+ GetVtbl(commandBuffer).CmdDispatchIndirect(commandBuffer, buffer, offset);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
++VKAPI_ATTR void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
+ GetVtbl(commandBuffer).CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
++VKAPI_ATTR void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
+ GetVtbl(commandBuffer).CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
++VKAPI_ATTR void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+ GetVtbl(commandBuffer).CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
++VKAPI_ATTR void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ GetVtbl(commandBuffer).CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
++VKAPI_ATTR void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ GetVtbl(commandBuffer).CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) {
++VKAPI_ATTR void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) {
+ GetVtbl(commandBuffer).CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
++VKAPI_ATTR void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+ GetVtbl(commandBuffer).CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
++VKAPI_ATTR void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ GetVtbl(commandBuffer).CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
++VKAPI_ATTR void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ GetVtbl(commandBuffer).CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
++VKAPI_ATTR void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+ GetVtbl(commandBuffer).CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
++VKAPI_ATTR void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+ GetVtbl(commandBuffer).CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
++VKAPI_ATTR void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+ GetVtbl(commandBuffer).CmdSetEvent(commandBuffer, event, stageMask);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
++VKAPI_ATTR void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+ GetVtbl(commandBuffer).CmdResetEvent(commandBuffer, event, stageMask);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) {
++VKAPI_ATTR void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) {
+ GetVtbl(commandBuffer).CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) {
++VKAPI_ATTR void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) {
+ GetVtbl(commandBuffer).CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags) {
++VKAPI_ATTR void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags) {
+ GetVtbl(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, entry, flags);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry) {
++VKAPI_ATTR void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry) {
+ GetVtbl(commandBuffer).CmdEndQuery(commandBuffer, queryPool, entry);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
++VKAPI_ATTR void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
+ GetVtbl(commandBuffer).CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry) {
++VKAPI_ATTR void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry) {
+ GetVtbl(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, entry);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
++VKAPI_ATTR void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
+ GetVtbl(commandBuffer).CmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) {
++VKAPI_ATTR void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) {
+ GetVtbl(commandBuffer).CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, values);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
++VKAPI_ATTR void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
+ GetVtbl(commandBuffer).CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
++VKAPI_ATTR void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+ GetVtbl(commandBuffer).CmdNextSubpass(commandBuffer, contents);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
++VKAPI_ATTR void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
+ GetVtbl(commandBuffer).CmdEndRenderPass(commandBuffer);
+ }
+
+ __attribute__((visibility("default")))
+-void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers) {
++VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers) {
+ GetVtbl(commandBuffer).CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface) {
++VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface) {
+ GetVtbl(instance).DestroySurfaceKHR(instance, surface);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
++VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
+ return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
++VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
+ return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
++VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
+ return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
++VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
+ return GetVtbl(physicalDevice).GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain) {
++VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain) {
+ return GetVtbl(device).CreateSwapchainKHR(device, pCreateInfo, pSwapchain);
+ }
+
+ __attribute__((visibility("default")))
+-void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain) {
++VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain) {
+ GetVtbl(device).DestroySwapchainKHR(device, swapchain);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
++VKAPI_ATTR VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
+ return GetVtbl(device).GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
++VKAPI_ATTR VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
+ return GetVtbl(device).AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkQueuePresentKHR(VkQueue queue, VkPresentInfoKHR* pPresentInfo) {
++VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, VkPresentInfoKHR* pPresentInfo) {
+ return GetVtbl(queue).QueuePresentKHR(queue, pPresentInfo);
+ }
+
+ __attribute__((visibility("default")))
+-VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, struct ANativeWindow* window, VkSurfaceKHR* pSurface) {
++VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, struct ANativeWindow* window, VkSurfaceKHR* pSurface) {
+ return GetVtbl(instance).CreateAndroidSurfaceKHR(instance, window, pSurface);
+ }
+diff --git a/vulkan/libvulkan/entry.cpp.tmpl b/vulkan/libvulkan/entry.cpp.tmpl
+index 712558b..5047741 100644
+--- a/vulkan/libvulkan/entry.cpp.tmpl
++++ b/vulkan/libvulkan/entry.cpp.tmpl
+@@ -124,7 +124,7 @@ namespace {
+ {{define "EmitSpecialEntry"}}
+ {{AssertType $ "Function"}}
+
+- {{Node "Type" $.Return}} {{Macro "FunctionName" $}}({{Macro "Parameters" $}}) {
++ VKAPI_ATTR {{Node "Type" $.Return}} {{Macro "FunctionName" $}}({{Macro "Parameters" $}}) {
+ {{if not (IsVoid $.Return.Type)}}return §{{end}}
+ vulkan::{{TrimPrefix "vk" $.Name}}({{Macro "Arguments" $}});
+ }
+@@ -142,7 +142,7 @@ namespace {
+ {{define "EmitEntry"}}
+ {{AssertType $ "Function"}}
+
+- {{Node "Type" $.Return}} {{Macro "FunctionName" $}}({{Macro "Parameters" $}}) {
++ VKAPI_ATTR {{Node "Type" $.Return}} {{Macro "FunctionName" $}}({{Macro "Parameters" $}}) {
+ {{if not (IsVoid $.Return.Type)}}return §{{end}}
+ {{Macro "Dispatch" $}}{{TrimPrefix "vk" $.Name}}({{Macro "Arguments" $}});
+ }
+diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
+index 135f06d..c24ef86 100644
+--- a/vulkan/libvulkan/loader.cpp
++++ b/vulkan/libvulkan/loader.cpp
+@@ -215,19 +215,19 @@ inline const DeviceVtbl* GetVtbl(VkQueue queue) {
+ return *reinterpret_cast<DeviceVtbl**>(queue);
+ }
+
+-void* DefaultAllocate(void*,
+- size_t size,
+- size_t alignment,
+- VkSystemAllocationScope) {
++VKAPI_ATTR void* DefaultAllocate(void*,
++ size_t size,
++ size_t alignment,
++ VkSystemAllocationScope) {
+ void* ptr = nullptr;
+ return posix_memalign(&ptr, alignment, size) == 0 ? ptr : nullptr;
+ }
+
+-void* DefaultReallocate(void*,
+- void* ptr,
+- size_t size,
+- size_t alignment,
+- VkSystemAllocationScope) {
++VKAPI_ATTR void* DefaultReallocate(void*,
++ void* ptr,
++ size_t size,
++ size_t alignment,
++ VkSystemAllocationScope) {
+ if (size == 0) {
+ free(ptr);
+ return nullptr;
+@@ -253,7 +253,7 @@ void* DefaultReallocate(void*,
+ return new_ptr;
+ }
+
+-void DefaultFree(void*, void* pMem) {
++VKAPI_ATTR void DefaultFree(void*, void* pMem) {
+ free(pMem);
+ }
+
+@@ -518,6 +518,7 @@ void FreeAllocatedCreateInfo(T& local_create_info,
+ const_cast<char**>(local_create_info.ppEnabledExtensionNames));
+ }
+
++VKAPI_ATTR
+ VkBool32 LogDebugMessageCallback(VkFlags message_flags,
+ VkDbgObjectType /*obj_type*/,
+ uint64_t /*src_object*/,
+@@ -538,7 +539,8 @@ VkResult Noop(...) {
+ return VK_SUCCESS;
+ }
+
+-PFN_vkVoidFunction GetLayerDeviceProcAddr(VkDevice device, const char* name) {
++VKAPI_ATTR PFN_vkVoidFunction
++GetLayerDeviceProcAddr(VkDevice device, const char* name) {
+ if (strcmp(name, "vkGetDeviceProcAddr") == 0) {
+ return reinterpret_cast<PFN_vkVoidFunction>(GetLayerDeviceProcAddr);
+ }
+@@ -571,6 +573,7 @@ PFN_vkVoidFunction GetLayerDeviceProcAddr(VkDevice device, const char* name) {
+ // "Bottom" functions. These are called at the end of the instance dispatch
+ // chain.
+
++VKAPI_ATTR
+ void DestroyInstanceBottom(VkInstance instance,
+ const VkAllocationCallbacks* allocator) {
+ // These checks allow us to call DestroyInstanceBottom from any error path
+@@ -596,6 +599,7 @@ void DestroyInstanceBottom(VkInstance instance,
+ alloc->pfnFree(alloc->pUserData, instance);
+ }
+
++VKAPI_ATTR
+ VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
+ const VkAllocationCallbacks* allocator,
+ VkInstance* instance_ptr) {
+@@ -673,6 +677,7 @@ VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
+ return VK_SUCCESS;
+ }
+
++VKAPI_ATTR
+ VkResult EnumeratePhysicalDevicesBottom(VkInstance instance,
+ uint32_t* pdev_count,
+ VkPhysicalDevice* pdevs) {
+@@ -686,11 +691,13 @@ VkResult EnumeratePhysicalDevicesBottom(VkInstance instance,
+ return VK_SUCCESS;
+ }
+
++VKAPI_ATTR
+ void GetPhysicalDeviceFeaturesBottom(VkPhysicalDevice pdev,
+ VkPhysicalDeviceFeatures* features) {
+ GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFeatures(pdev, features);
+ }
+
++VKAPI_ATTR
+ void GetPhysicalDeviceFormatPropertiesBottom(VkPhysicalDevice pdev,
+ VkFormat format,
+ VkFormatProperties* properties) {
+@@ -698,6 +705,7 @@ void GetPhysicalDeviceFormatPropertiesBottom(VkPhysicalDevice pdev,
+ pdev, format, properties);
+ }
+
++VKAPI_ATTR
+ VkResult GetPhysicalDeviceImageFormatPropertiesBottom(
+ VkPhysicalDevice pdev,
+ VkFormat format,
+@@ -711,12 +719,14 @@ VkResult GetPhysicalDeviceImageFormatPropertiesBottom(
+ pdev, format, type, tiling, usage, flags, properties);
+ }
+
++VKAPI_ATTR
+ void GetPhysicalDevicePropertiesBottom(VkPhysicalDevice pdev,
+ VkPhysicalDeviceProperties* properties) {
+ GetVtbl(pdev)
+ ->instance->drv.vtbl.GetPhysicalDeviceProperties(pdev, properties);
+ }
+
++VKAPI_ATTR
+ void GetPhysicalDeviceQueueFamilyPropertiesBottom(
+ VkPhysicalDevice pdev,
+ uint32_t* pCount,
+@@ -725,6 +735,7 @@ void GetPhysicalDeviceQueueFamilyPropertiesBottom(
+ pdev, pCount, properties);
+ }
+
++VKAPI_ATTR
+ void GetPhysicalDeviceMemoryPropertiesBottom(
+ VkPhysicalDevice pdev,
+ VkPhysicalDeviceMemoryProperties* properties) {
+@@ -732,6 +743,7 @@ void GetPhysicalDeviceMemoryPropertiesBottom(
+ pdev, properties);
+ }
+
++VKAPI_ATTR
+ VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
+ const VkDeviceCreateInfo* create_info,
+ const VkAllocationCallbacks* allocator,
+@@ -840,6 +852,7 @@ VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
+ return VK_SUCCESS;
+ }
+
++VKAPI_ATTR
+ VkResult EnumerateDeviceExtensionPropertiesBottom(
+ VkPhysicalDevice pdev,
+ const char* layer_name,
+@@ -850,6 +863,7 @@ VkResult EnumerateDeviceExtensionPropertiesBottom(
+ pdev, layer_name, properties_count, properties);
+ }
+
++VKAPI_ATTR
+ VkResult EnumerateDeviceLayerPropertiesBottom(VkPhysicalDevice pdev,
+ uint32_t* properties_count,
+ VkLayerProperties* properties) {
+@@ -857,6 +871,7 @@ VkResult EnumerateDeviceLayerPropertiesBottom(VkPhysicalDevice pdev,
+ pdev, properties_count, properties);
+ }
+
++VKAPI_ATTR
+ void GetPhysicalDeviceSparseImageFormatPropertiesBottom(
+ VkPhysicalDevice pdev,
+ VkFormat format,
+@@ -872,7 +887,8 @@ void GetPhysicalDeviceSparseImageFormatPropertiesBottom(
+ properties);
+ }
+
+-PFN_vkVoidFunction GetInstanceProcAddrBottom(VkInstance, const char*);
++VKAPI_ATTR PFN_vkVoidFunction
++GetInstanceProcAddrBottom(VkInstance, const char*);
+
+ const InstanceVtbl kBottomInstanceFunctions = {
+ // clang-format off
+@@ -898,6 +914,7 @@ const InstanceVtbl kBottomInstanceFunctions = {
+ // clang-format on
+ };
+
++VKAPI_ATTR
+ PFN_vkVoidFunction GetInstanceProcAddrBottom(VkInstance, const char* name) {
+ // TODO: Possibly move this into the instance table
+ // TODO: Possibly register the callbacks in the loader
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index 5765d65..6aa8673 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -261,40 +261,45 @@ bool LoadDeviceVtbl(VkDevice device,
+ // -----------------------------------------------------------------------------
+ // swapchain.cpp
+
+-VkResult CreateAndroidSurfaceKHR(VkInstance instance,
+- ANativeWindow* window,
+- VkSurfaceKHR* surface);
+-void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface);
+-VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev,
+- uint32_t queue_family,
+- VkSurfaceKHR surface,
+- VkBool32* pSupported);
+-VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
+- VkPhysicalDevice pdev,
+- VkSurfaceKHR surface,
+- VkSurfaceCapabilitiesKHR* capabilities);
+-VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
+- VkSurfaceKHR surface,
+- uint32_t* count,
+- VkSurfaceFormatKHR* formats);
+-VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
+- VkSurfaceKHR surface,
+- uint32_t* count,
+- VkPresentModeKHR* modes);
+-VkResult CreateSwapchainKHR(VkDevice device,
+- const VkSwapchainCreateInfoKHR* create_info,
+- VkSwapchainKHR* swapchain_handle);
+-VkResult DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain_handle);
+-VkResult GetSwapchainImagesKHR(VkDevice device,
+- VkSwapchainKHR swapchain_handle,
+- uint32_t* count,
+- VkImage* images);
+-VkResult AcquireNextImageKHR(VkDevice device,
+- VkSwapchainKHR swapchain_handle,
+- uint64_t timeout,
+- VkSemaphore semaphore,
+- uint32_t* image_index);
+-VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info);
++VKAPI_ATTR VkResult CreateAndroidSurfaceKHR(VkInstance instance,
++ ANativeWindow* window,
++ VkSurfaceKHR* surface);
++VKAPI_ATTR void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface);
++VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev,
++ uint32_t queue_family,
++ VkSurfaceKHR surface,
++ VkBool32* pSupported);
++VKAPI_ATTR VkResult
++GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice pdev,
++ VkSurfaceKHR surface,
++ VkSurfaceCapabilitiesKHR* capabilities);
++VKAPI_ATTR VkResult
++GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
++ VkSurfaceKHR surface,
++ uint32_t* count,
++ VkSurfaceFormatKHR* formats);
++VKAPI_ATTR VkResult
++GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
++ VkSurfaceKHR surface,
++ uint32_t* count,
++ VkPresentModeKHR* modes);
++VKAPI_ATTR VkResult
++CreateSwapchainKHR(VkDevice device,
++ const VkSwapchainCreateInfoKHR* create_info,
++ VkSwapchainKHR* swapchain_handle);
++VKAPI_ATTR VkResult
++DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain_handle);
++VKAPI_ATTR VkResult GetSwapchainImagesKHR(VkDevice device,
++ VkSwapchainKHR swapchain_handle,
++ uint32_t* count,
++ VkImage* images);
++VKAPI_ATTR VkResult AcquireNextImageKHR(VkDevice device,
++ VkSwapchainKHR swapchain_handle,
++ uint64_t timeout,
++ VkSemaphore semaphore,
++ uint32_t* image_index);
++VKAPI_ATTR VkResult
++QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info);
+
+ } // namespace vulkan
+
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index 98faaef..fa5ea59 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -141,6 +141,7 @@ Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
+
+ namespace vulkan {
+
++VKAPI_ATTR
+ VkResult CreateAndroidSurfaceKHR(VkInstance instance,
+ ANativeWindow* window,
+ VkSurfaceKHR* out_surface) {
+@@ -169,6 +170,7 @@ VkResult CreateAndroidSurfaceKHR(VkInstance instance,
+ return VK_SUCCESS;
+ }
+
++VKAPI_ATTR
+ void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface_handle) {
+ Surface* surface = SurfaceFromHandle(surface_handle);
+ if (!surface)
+@@ -178,6 +180,7 @@ void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface_handle) {
+ FreeMem(instance, surface);
+ }
+
++VKAPI_ATTR
+ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
+ uint32_t /*queue_family*/,
+ VkSurfaceKHR /*surface*/,
+@@ -186,6 +189,7 @@ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
+ return VK_SUCCESS;
+ }
+
++VKAPI_ATTR
+ VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice /*pdev*/,
+ VkSurfaceKHR surface,
+@@ -242,6 +246,7 @@ VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ return VK_SUCCESS;
+ }
+
++VKAPI_ATTR
+ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice /*pdev*/,
+ VkSurfaceKHR /*surface*/,
+ uint32_t* count,
+@@ -268,6 +273,7 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice /*pdev*/,
+ return result;
+ }
+
++VKAPI_ATTR
+ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice /*pdev*/,
+ VkSurfaceKHR /*surface*/,
+ uint32_t* count,
+@@ -287,6 +293,7 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice /*pdev*/,
+ return result;
+ }
+
++VKAPI_ATTR
+ VkResult CreateSwapchainKHR(VkDevice device,
+ const VkSwapchainCreateInfoKHR* create_info,
+ VkSwapchainKHR* swapchain_handle) {
+@@ -475,6 +482,7 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ return VK_SUCCESS;
+ }
+
++VKAPI_ATTR
+ VkResult DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain_handle) {
+ const DeviceVtbl& driver_vtbl = GetDriverVtbl(device);
+ Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
+@@ -499,6 +507,7 @@ VkResult DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain_handle) {
+ return VK_SUCCESS;
+ }
+
++VKAPI_ATTR
+ VkResult GetSwapchainImagesKHR(VkDevice,
+ VkSwapchainKHR swapchain_handle,
+ uint32_t* count,
+@@ -518,6 +527,7 @@ VkResult GetSwapchainImagesKHR(VkDevice,
+ return result;
+ }
+
++VKAPI_ATTR
+ VkResult AcquireNextImageKHR(VkDevice device,
+ VkSwapchainKHR swapchain_handle,
+ uint64_t timeout,
+@@ -598,6 +608,7 @@ VkResult AcquireNextImageKHR(VkDevice device,
+ return VK_SUCCESS;
+ }
+
++VKAPI_ATTR
+ VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info) {
+ #pragma clang diagnostic push
+ #pragma clang diagnostic ignored "-Wold-style-cast"
+diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
+index 316d27f..4fd0103 100644
+--- a/vulkan/nulldrv/null_driver.cpp
++++ b/vulkan/nulldrv/null_driver.cpp
+@@ -129,6 +129,7 @@ __attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = {
+
+ namespace {
+
++VKAPI_ATTR
+ VkResult CreateInstance(const VkInstanceCreateInfo* /*create_info*/,
+ const VkAllocationCallbacks* allocator,
+ VkInstance* out_instance) {
+@@ -212,6 +213,7 @@ namespace null_driver {
+ // -----------------------------------------------------------------------------
+ // Global
+
++VKAPI_ATTR
+ VkResult EnumerateInstanceExtensionProperties(const char*,
+ uint32_t* count,
+ VkExtensionProperties*) {
+@@ -219,6 +221,7 @@ VkResult EnumerateInstanceExtensionProperties(const char*,
+ return VK_SUCCESS;
+ }
+
++VKAPI_ATTR
+ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance, const char* name) {
+ PFN_vkVoidFunction proc = LookupInstanceProcAddr(name);
+ if (!proc && strcmp(name, "vkGetDeviceProcAddr") == 0)
+@@ -226,6 +229,7 @@ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance, const char* name) {
+ return proc;
+ }
+
++VKAPI_ATTR
+ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) {
+ PFN_vkVoidFunction proc = LookupDeviceProcAddr(name);
+ if (proc)
+diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
+index 1a524ff..1018afa 100644
+--- a/vulkan/nulldrv/null_driver.h
++++ b/vulkan/nulldrv/null_driver.h
+@@ -27,146 +27,146 @@ PFN_vkVoidFunction LookupInstanceProcAddr(const char* name);
+ PFN_vkVoidFunction LookupDeviceProcAddr(const char* name);
+
+ // clang-format off
+-void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* allocator);
+-VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+-void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+-void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+-VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+-void GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+-void GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+-void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+-PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
+-PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
+-VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDevice* pDevice);
+-void DestroyDevice(VkDevice device, const VkAllocationCallbacks* allocator);
+-VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+-VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
+-VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);
+-VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
+-void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+-VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
+-VkResult QueueWaitIdle(VkQueue queue);
+-VkResult DeviceWaitIdle(VkDevice device);
+-VkResult AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocInfo, const VkAllocationCallbacks* allocator, VkDeviceMemory* pMem);
+-void FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* allocator);
+-VkResult MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
+-void UnmapMemory(VkDevice device, VkDeviceMemory mem);
+-VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+-VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+-void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+-VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
+-VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
+-void GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+-void GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+-void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+-void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+-VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
+-VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkFence* pFence);
+-void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator);
+-VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
+-VkResult GetFenceStatus(VkDevice device, VkFence fence);
+-VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
+-VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkSemaphore* pSemaphore);
+-void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* allocator);
+-VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkEvent* pEvent);
+-void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* allocator);
+-VkResult GetEventStatus(VkDevice device, VkEvent event);
+-VkResult SetEvent(VkDevice device, VkEvent event);
+-VkResult ResetEvent(VkDevice device, VkEvent event);
+-VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkQueryPool* pQueryPool);
+-void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* allocator);
+-VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+-VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkBuffer* pBuffer);
+-void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* allocator);
+-VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkBufferView* pView);
+-void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* allocator);
+-VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkImage* pImage);
+-void DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* allocator);
+-void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+-VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkImageView* pView);
+-void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator);
+-VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkShaderModule* pShaderModule);
+-void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator);
+-VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkPipelineCache* pPipelineCache);
+-void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator);
+-VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+-VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+-VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* allocator, VkPipeline* pPipelines);
+-VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* allocator, VkPipeline* pPipelines);
+-void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* allocator);
+-VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkPipelineLayout* pPipelineLayout);
+-void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* allocator);
+-VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkSampler* pSampler);
+-void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* allocator);
+-VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDescriptorSetLayout* pSetLayout);
+-void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* allocator);
+-VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDescriptorPool* pDescriptorPool);
+-void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* allocator);
+-VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+-VkResult AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
+-VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
+-void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+-VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkFramebuffer* pFramebuffer);
+-void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* allocator);
+-VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkRenderPass* pRenderPass);
+-void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* allocator);
+-void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+-VkResult CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkCommandPool* pCmdPool);
+-void DestroyCommandPool(VkDevice device, VkCommandPool cmdPool, const VkAllocationCallbacks* allocator);
+-VkResult ResetCommandPool(VkDevice device, VkCommandPool cmdPool, VkCommandPoolResetFlags flags);
+-VkResult AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocInfo, VkCommandBuffer* pCmdBuffers);
+-void FreeCommandBuffers(VkDevice device, VkCommandPool cmdPool, uint32_t count, const VkCommandBuffer* pCommandBuffers);
+-VkResult BeginCommandBuffer(VkCommandBuffer cmdBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+-VkResult EndCommandBuffer(VkCommandBuffer cmdBuffer);
+-VkResult ResetCommandBuffer(VkCommandBuffer cmdBuffer, VkCommandBufferResetFlags flags);
+-void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+-void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
+-void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
+-void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth);
+-void CmdSetDepthBias(VkCommandBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias);
+-void CmdSetBlendConstants(VkCommandBuffer cmdBuffer, const float blendConst[4]);
+-void CmdSetDepthBounds(VkCommandBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
+-void CmdSetStencilCompareMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
+-void CmdSetStencilWriteMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
+-void CmdSetStencilReference(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
+-void CmdBindDescriptorSets(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+-void CmdBindIndexBuffer(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+-void CmdBindVertexBuffers(VkCommandBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+-void CmdDraw(VkCommandBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+-void CmdDrawIndexed(VkCommandBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+-void CmdDrawIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
+-void CmdDrawIndexedIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
+-void CmdDispatch(VkCommandBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
+-void CmdDispatchIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
+-void CmdCopyBuffer(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+-void CmdCopyImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+-void CmdBlitImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+-void CmdCopyBufferToImage(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+-void CmdCopyImageToBuffer(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+-void CmdUpdateBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
+-void CmdFillBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
+-void CmdClearColorImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-void CmdClearDepthStencilImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+-void CmdClearAttachments(VkCommandBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+-void CmdResolveImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+-void CmdSetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+-void CmdResetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+-void CmdWaitEvents(VkCommandBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+-void CmdPipelineBarrier(VkCommandBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+-void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+-void CmdEndQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+-void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+-void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
+-void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
+-void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
+-void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
+-void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkSubpassContents contents);
+-void CmdEndRenderPass(VkCommandBuffer cmdBuffer);
+-void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers);
++VKAPI_ATTR void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
++VKAPI_ATTR void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
++VKAPI_ATTR void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
++VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
++VKAPI_ATTR void GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
++VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
++VKAPI_ATTR void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
++VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
++VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
++VKAPI_ATTR VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDevice* pDevice);
++VKAPI_ATTR void DestroyDevice(VkDevice device, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
++VKAPI_ATTR VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
++VKAPI_ATTR VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);
++VKAPI_ATTR VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
++VKAPI_ATTR void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
++VKAPI_ATTR VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
++VKAPI_ATTR VkResult QueueWaitIdle(VkQueue queue);
++VKAPI_ATTR VkResult DeviceWaitIdle(VkDevice device);
++VKAPI_ATTR VkResult AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocInfo, const VkAllocationCallbacks* allocator, VkDeviceMemory* pMem);
++VKAPI_ATTR void FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
++VKAPI_ATTR void UnmapMemory(VkDevice device, VkDeviceMemory mem);
++VKAPI_ATTR VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
++VKAPI_ATTR VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
++VKAPI_ATTR void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
++VKAPI_ATTR VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
++VKAPI_ATTR VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
++VKAPI_ATTR void GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
++VKAPI_ATTR void GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
++VKAPI_ATTR void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
++VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
++VKAPI_ATTR VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
++VKAPI_ATTR VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkFence* pFence);
++VKAPI_ATTR void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
++VKAPI_ATTR VkResult GetFenceStatus(VkDevice device, VkFence fence);
++VKAPI_ATTR VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
++VKAPI_ATTR VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkSemaphore* pSemaphore);
++VKAPI_ATTR void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkEvent* pEvent);
++VKAPI_ATTR void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult GetEventStatus(VkDevice device, VkEvent event);
++VKAPI_ATTR VkResult SetEvent(VkDevice device, VkEvent event);
++VKAPI_ATTR VkResult ResetEvent(VkDevice device, VkEvent event);
++VKAPI_ATTR VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkQueryPool* pQueryPool);
++VKAPI_ATTR void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
++VKAPI_ATTR VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkBuffer* pBuffer);
++VKAPI_ATTR void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkBufferView* pView);
++VKAPI_ATTR void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkImage* pImage);
++VKAPI_ATTR void DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
++VKAPI_ATTR VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkImageView* pView);
++VKAPI_ATTR void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkShaderModule* pShaderModule);
++VKAPI_ATTR void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkPipelineCache* pPipelineCache);
++VKAPI_ATTR void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
++VKAPI_ATTR VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
++VKAPI_ATTR VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* allocator, VkPipeline* pPipelines);
++VKAPI_ATTR VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* allocator, VkPipeline* pPipelines);
++VKAPI_ATTR void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkPipelineLayout* pPipelineLayout);
++VKAPI_ATTR void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkSampler* pSampler);
++VKAPI_ATTR void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDescriptorSetLayout* pSetLayout);
++VKAPI_ATTR void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDescriptorPool* pDescriptorPool);
++VKAPI_ATTR void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
++VKAPI_ATTR VkResult AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
++VKAPI_ATTR VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
++VKAPI_ATTR void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
++VKAPI_ATTR VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkFramebuffer* pFramebuffer);
++VKAPI_ATTR void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkRenderPass* pRenderPass);
++VKAPI_ATTR void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
++VKAPI_ATTR VkResult CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkCommandPool* pCmdPool);
++VKAPI_ATTR void DestroyCommandPool(VkDevice device, VkCommandPool cmdPool, const VkAllocationCallbacks* allocator);
++VKAPI_ATTR VkResult ResetCommandPool(VkDevice device, VkCommandPool cmdPool, VkCommandPoolResetFlags flags);
++VKAPI_ATTR VkResult AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocInfo, VkCommandBuffer* pCmdBuffers);
++VKAPI_ATTR void FreeCommandBuffers(VkDevice device, VkCommandPool cmdPool, uint32_t count, const VkCommandBuffer* pCommandBuffers);
++VKAPI_ATTR VkResult BeginCommandBuffer(VkCommandBuffer cmdBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
++VKAPI_ATTR VkResult EndCommandBuffer(VkCommandBuffer cmdBuffer);
++VKAPI_ATTR VkResult ResetCommandBuffer(VkCommandBuffer cmdBuffer, VkCommandBufferResetFlags flags);
++VKAPI_ATTR void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
++VKAPI_ATTR void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
++VKAPI_ATTR void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
++VKAPI_ATTR void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth);
++VKAPI_ATTR void CmdSetDepthBias(VkCommandBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias);
++VKAPI_ATTR void CmdSetBlendConstants(VkCommandBuffer cmdBuffer, const float blendConst[4]);
++VKAPI_ATTR void CmdSetDepthBounds(VkCommandBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
++VKAPI_ATTR void CmdSetStencilCompareMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
++VKAPI_ATTR void CmdSetStencilWriteMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
++VKAPI_ATTR void CmdSetStencilReference(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
++VKAPI_ATTR void CmdBindDescriptorSets(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
++VKAPI_ATTR void CmdBindIndexBuffer(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
++VKAPI_ATTR void CmdBindVertexBuffers(VkCommandBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
++VKAPI_ATTR void CmdDraw(VkCommandBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
++VKAPI_ATTR void CmdDrawIndexed(VkCommandBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
++VKAPI_ATTR void CmdDrawIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
++VKAPI_ATTR void CmdDrawIndexedIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
++VKAPI_ATTR void CmdDispatch(VkCommandBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
++VKAPI_ATTR void CmdDispatchIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
++VKAPI_ATTR void CmdCopyBuffer(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
++VKAPI_ATTR void CmdCopyImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
++VKAPI_ATTR void CmdBlitImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
++VKAPI_ATTR void CmdCopyBufferToImage(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
++VKAPI_ATTR void CmdCopyImageToBuffer(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
++VKAPI_ATTR void CmdUpdateBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
++VKAPI_ATTR void CmdFillBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
++VKAPI_ATTR void CmdClearColorImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
++VKAPI_ATTR void CmdClearDepthStencilImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
++VKAPI_ATTR void CmdClearAttachments(VkCommandBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
++VKAPI_ATTR void CmdResolveImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
++VKAPI_ATTR void CmdSetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
++VKAPI_ATTR void CmdResetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
++VKAPI_ATTR void CmdWaitEvents(VkCommandBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
++VKAPI_ATTR void CmdPipelineBarrier(VkCommandBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
++VKAPI_ATTR void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
++VKAPI_ATTR void CmdEndQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
++VKAPI_ATTR void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
++VKAPI_ATTR void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
++VKAPI_ATTR void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
++VKAPI_ATTR void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
++VKAPI_ATTR void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
++VKAPI_ATTR void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkSubpassContents contents);
++VKAPI_ATTR void CmdEndRenderPass(VkCommandBuffer cmdBuffer);
++VKAPI_ATTR void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers);
+
+-VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
+-VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore);
+-VkResult QueueSignalReleaseImageANDROID(VkQueue queue, VkImage image, int* pNativeFenceFd);
++VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
++VKAPI_ATTR VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore);
++VKAPI_ATTR VkResult QueueSignalReleaseImageANDROID(VkQueue queue, VkImage image, int* pNativeFenceFd);
+ // clang-format on
+
+ } // namespace null_driver
+--
+2.4.0
+
--- /dev/null
+From 091923b2022e23b128e8de404cef2b7f70e80b8e Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 30 Nov 2015 11:37:59 -0800
+Subject: [PATCH 25/30] vulkan: Update from version 0.204.0 to 0.205.0
+
+Change-Id: Ic0b91f338bcddc50b4617da266347ae8b9cc29fa
+---
+ vulkan/api/vulkan.api | 43 ++++++++++++++++++------------
+ vulkan/include/vulkan/vulkan.h | 59 +++++++++++++++++++++++++-----------------
+ vulkan/libvulkan/entry.cpp | 16 ++++++------
+ vulkan/libvulkan/loader.h | 22 ++++++++++------
+ vulkan/libvulkan/swapchain.cpp | 14 +++++++---
+ 5 files changed, 94 insertions(+), 60 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index c77a148..1c4bb8f 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 204
++define VERSION_MINOR 205
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -45,43 +45,43 @@ define VK_FALSE 0
+ // API keyword, but needs special handling by some templates
+ define NULL_HANDLE 0
+
+-@extension("VK_KHR_surface") define VK_KHR_SURFACE_REVISION 22
++@extension("VK_KHR_surface") define VK_KHR_SURFACE_REVISION 23
+ @extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NUMBER 1
+ @extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"
+
+-@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_REVISION 65
++@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_REVISION 66
+ @extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+ @extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
+
+-@extension("VK_KHR_display") define VK_KHR_DISPLAY_REVISION 18
++@extension("VK_KHR_display") define VK_KHR_DISPLAY_REVISION 19
+ @extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NUMBER 3
+ @extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"
+
+-@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_REVISION 7
+-@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_EXTENSION_NUMBER 4
+-@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display_swapchain"
++@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_REVISION 8
++@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4
++@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
+
+-@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_REVISION 4
++@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_REVISION 5
+ @extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_NUMBER 5
+ @extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_NAME "VK_KHR_xlib_surface"
+
+-@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_REVISION 4
++@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_REVISION 5
+ @extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_NUMBER 6
+ @extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_NAME "VK_KHR_xcb_surface"
+
+-@extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_REVISION 3
++@extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_REVISION 4
+ @extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_NUMBER 7
+ @extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_NAME "VK_KHR_wayland_surface"
+
+-@extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_REVISION 3
++@extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_REVISION 4
+ @extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_NUMBER 8
+ @extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_NAME "VK_KHR_mir_surface"
+
+-@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_REVISION 2
++@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_REVISION 3
+ @extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_NUMBER 8
+ @extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_NAME "VK_KHR_android_surface"
+
+-@extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_REVISION 3
++@extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_REVISION 4
+ @extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_NUMBER 9
+ @extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_NAME "VK_KHR_win32_surface"
+
+@@ -4594,7 +4594,8 @@ cmd void vkCmdExecuteCommands(
+ @extension("VK_KHR_surface")
+ cmd void vkDestroySurfaceKHR(
+ VkInstance instance,
+- VkSurfaceKHR surface) {
++ VkSurfaceKHR surface,
++ const VkAllocationCallbacks* pAllocator) {
+ instanceObject := GetInstance(instance)
+ surfaceObject := GetSurface(surface)
+ assert(surfaceObject.instance == instance)
+@@ -4670,6 +4671,7 @@ cmd VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
+ cmd VkResult vkCreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
++ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR)
+ deviceObject := GetDevice(device)
+@@ -4684,7 +4686,8 @@ cmd VkResult vkCreateSwapchainKHR(
+ @extension("VK_KHR_swapchain")
+ cmd void vkDestroySwapchainKHR(
+ VkDevice device,
+- VkSwapchainKHR swapchain) {
++ VkSwapchainKHR swapchain,
++ const VkAllocationCallbacks* pAllocator) {
+ deviceObject := GetDevice(device)
+ swapchainObject := GetSwapchain(swapchain)
+ assert(swapchainObject.device == device)
+@@ -4784,6 +4787,7 @@ cmd VkResult vkCreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
++ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+ return ?
+@@ -4803,6 +4807,7 @@ cmd VkResult vkGetDisplayPlaneCapabilitiesKHR(
+ cmd VkResult vkCreateDisplayPlaneSurfaceKHR(
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+ return ?
+ }
+@@ -4812,6 +4817,7 @@ cmd VkResult vkCreateXlibSurfaceKHR(
+ VkInstance instance,
+ platform.Display* dpy,
+ platform.Window window,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+ instanceObject := GetInstance(instance)
+ return ?
+@@ -4832,6 +4838,7 @@ cmd VkResult vkCreateXCBSurfaceKHR(
+ VkInstance instance,
+ platform.xcb_connection_t* connection,
+ platform.xcb_window_t window,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+ instanceObject := GetInstance(instance)
+ return ?
+@@ -4852,6 +4859,7 @@ cmd VkResult vkCreateWaylandSurfaceKHR(
+ VkInstance instance,
+ platform.wl_display* display,
+ platform.wl_surface* surface,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+ instanceObject := GetInstance(instance)
+ return ?
+@@ -4871,6 +4879,7 @@ cmd VkResult vkCreateMirSurfaceKHR(
+ VkInstance instance,
+ platform.MirConnection* connection,
+ platform.MirSurface* mirSurface,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+ instanceObject := GetInstance(instance)
+ return ?
+@@ -4888,7 +4897,8 @@ cmd VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR(
+ @extension("VK_KHR_android_surface")
+ cmd VkResult vkCreateAndroidSurfaceKHR(
+ VkInstance instance,
+- platform.ANativeWindow* window
++ platform.ANativeWindow* window,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+ instanceObject := GetInstance(instance)
+ return ?
+@@ -4899,6 +4909,7 @@ cmd VkResult vkCreateWin32SurfaceKHR(
+ VkInstance instance,
+ platform.HINSTANCE hinstance,
+ platform.HWND hwnd,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
+ instanceObject := GetInstance(instance)
+ return ?
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 2791b8a..b342285 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 204, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 205, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -3068,7 +3068,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
+ #define VK_KHR_surface 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
+
+-#define VK_KHR_SURFACE_REVISION 22
++#define VK_KHR_SURFACE_REVISION 23
+ #define VK_KHR_SURFACE_EXTENSION_NUMBER 1
+ #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"
+ #define VK_ERROR_SURFACE_LOST_KHR ((VkResult)(int)0xc0000400)
+@@ -3150,7 +3150,7 @@ typedef struct VkSurfaceFormatKHR {
+ } VkSurfaceFormatKHR;
+
+
+-typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface);
++typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
+@@ -3159,7 +3159,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPh
+ #ifdef VK_PROTOTYPES
+ VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
+ VkInstance instance,
+- VkSurfaceKHR surface);
++ VkSurfaceKHR surface,
++ const VkAllocationCallbacks* pAllocator);
+
+ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+@@ -3188,7 +3189,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
+ #define VK_KHR_swapchain 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
+
+-#define VK_KHR_SWAPCHAIN_REVISION 65
++#define VK_KHR_SWAPCHAIN_REVISION 66
+ #define VK_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+ #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
+ #define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
+@@ -3229,8 +3230,8 @@ typedef struct VkPresentInfoKHR {
+ } VkPresentInfoKHR;
+
+
+-typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain);
+-typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
++typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
+ typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
+ typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo);
+@@ -3239,11 +3240,13 @@ typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInf
+ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
++ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain);
+
+ VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
+ VkDevice device,
+- VkSwapchainKHR swapchain);
++ VkSwapchainKHR swapchain,
++ const VkAllocationCallbacks* pAllocator);
+
+ VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
+ VkDevice device,
+@@ -3268,7 +3271,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
+
+-#define VK_KHR_DISPLAY_REVISION 18
++#define VK_KHR_DISPLAY_REVISION 19
+ #define VK_KHR_DISPLAY_EXTENSION_NUMBER 3
+ #define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"
+ #define VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c00)
+@@ -3342,9 +3345,9 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhys
+ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayKHR* pProperties);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
+-typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, VkDisplayModeKHR* pMode);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeCreateInfoKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+-typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, VkSurfaceKHR* pSurface);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+ #ifdef VK_PROTOTYPES
+ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
+@@ -3372,6 +3375,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
++ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode);
+
+ VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
+@@ -3383,11 +3387,12 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
+ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ #endif
+
+ #define VK_KHR_display_swapchain 1
+-#define VK_KHR_DISPLAY_SWAPCHAIN_REVISION 7
++#define VK_KHR_DISPLAY_SWAPCHAIN_REVISION 8
+ #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4
+ #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
+ #define VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0001000)
+@@ -3414,11 +3419,11 @@ typedef struct VkDisplayPresentInfoKHR {
+ #define VK_KHR_xlib_surface 1
+ #include <X11/Xlib.h>
+
+-#define VK_KHR_XLIB_SURFACE_REVISION 4
++#define VK_KHR_XLIB_SURFACE_REVISION 5
+ #define VK_KHR_XLIB_SURFACE_EXTENSION_NUMBER 5
+ #define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
+
+-typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, VkSurfaceKHR* pSurface);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+ typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
+
+ #ifdef VK_PROTOTYPES
+@@ -3426,6 +3431,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
+ VkInstance instance,
+ Display* dpy,
+ Window window,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+
+ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
+@@ -3440,11 +3446,11 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ #define VK_KHR_xcb_surface 1
+ #include <xcb/xcb.h>
+
+-#define VK_KHR_XCB_SURFACE_REVISION 4
++#define VK_KHR_XCB_SURFACE_REVISION 5
+ #define VK_KHR_XCB_SURFACE_EXTENSION_NUMBER 6
+ #define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
+
+-typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, xcb_connection_t* connection, xcb_window_t window, VkSurfaceKHR* pSurface);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, xcb_connection_t* connection, xcb_window_t window, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+ typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
+
+ #ifdef VK_PROTOTYPES
+@@ -3452,6 +3458,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
+ VkInstance instance,
+ xcb_connection_t* connection,
+ xcb_window_t window,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+
+ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
+@@ -3466,11 +3473,11 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ #define VK_KHR_wayland_surface 1
+ #include <wayland-client.h>
+
+-#define VK_KHR_WAYLAND_SURFACE_REVISION 3
++#define VK_KHR_WAYLAND_SURFACE_REVISION 4
+ #define VK_KHR_WAYLAND_SURFACE_EXTENSION_NUMBER 7
+ #define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
+
+-typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, struct wl_display* display, struct wl_surface* surface, VkSurfaceKHR* pSurface);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, struct wl_display* display, struct wl_surface* surface, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+ typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
+
+ #ifdef VK_PROTOTYPES
+@@ -3478,6 +3485,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
+ VkInstance instance,
+ struct wl_display* display,
+ struct wl_surface* surface,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+
+ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+@@ -3491,11 +3499,11 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ #define VK_KHR_mir_surface 1
+ #include <mir_toolkit/client_types.h>
+
+-#define VK_KHR_MIR_SURFACE_REVISION 3
++#define VK_KHR_MIR_SURFACE_REVISION 4
+ #define VK_KHR_MIR_SURFACE_EXTENSION_NUMBER 8
+ #define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
+
+-typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, MirConnection* connection, MirSurface* mirSurface, VkSurfaceKHR* pSurface);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, MirConnection* connection, MirSurface* mirSurface, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+ typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
+
+ #ifdef VK_PROTOTYPES
+@@ -3503,6 +3511,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
+ VkInstance instance,
+ MirConnection* connection,
+ MirSurface* mirSurface,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+
+ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
+@@ -3516,18 +3525,19 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
+ #define VK_KHR_android_surface 1
+ #include <android/native_window.h>
+
+-#define VK_KHR_ANDROID_SURFACE_REVISION 2
++#define VK_KHR_ANDROID_SURFACE_REVISION 3
+ #define VK_KHR_ANDROID_SURFACE_EXTENSION_NUMBER 9
+ #define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
+ #define VK_ERROR_INVALID_ANDROID_WINDOW_KHR ((VkResult)(int)0xc0002400)
+ #define VK_ERROR_ANDROID_WINDOW_IN_USE_KHR ((VkResult)(int)0xc0002401)
+
+-typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, ANativeWindow* window, VkSurfaceKHR* pSurface);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, ANativeWindow* window, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+ #ifdef VK_PROTOTYPES
+ VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
+ VkInstance instance,
+ ANativeWindow* window,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+ #endif
+ #endif /* VK_USE_PLATFORM_ANDROID_KHR */
+@@ -3536,11 +3546,11 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
+ #define VK_KHR_win32_surface 1
+ #include <windows.h>
+
+-#define VK_KHR_WIN32_SURFACE_REVISION 3
++#define VK_KHR_WIN32_SURFACE_REVISION 4
+ #define VK_KHR_WIN32_SURFACE_EXTENSION_NUMBER 10
+ #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
+
+-typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, HINSTANCE hinstance, HWND hwnd, VkSurfaceKHR* pSurface);
++typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, HINSTANCE hinstance, HWND hwnd, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+ typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
+
+ #ifdef VK_PROTOTYPES
+@@ -3548,6 +3558,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
+ VkInstance instance,
+ HINSTANCE hinstance,
+ HWND hwnd,
++ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface);
+
+ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 7b8db6b..67b8c38 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -727,8 +727,8 @@ VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t com
+ }
+
+ __attribute__((visibility("default")))
+-VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface) {
+- GetVtbl(instance).DestroySurfaceKHR(instance, surface);
++VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {
++ GetVtbl(instance).DestroySurfaceKHR(instance, surface, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -752,13 +752,13 @@ VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice p
+ }
+
+ __attribute__((visibility("default")))
+-VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain) {
+- return GetVtbl(device).CreateSwapchainKHR(device, pCreateInfo, pSwapchain);
++VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
++ return GetVtbl(device).CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
+ }
+
+ __attribute__((visibility("default")))
+-VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain) {
+- GetVtbl(device).DestroySwapchainKHR(device, swapchain);
++VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
++ GetVtbl(device).DestroySwapchainKHR(device, swapchain, pAllocator);
+ }
+
+ __attribute__((visibility("default")))
+@@ -777,6 +777,6 @@ VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, VkPresentInfoKHR* pPresentI
+ }
+
+ __attribute__((visibility("default")))
+-VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, struct ANativeWindow* window, VkSurfaceKHR* pSurface) {
+- return GetVtbl(instance).CreateAndroidSurfaceKHR(instance, window, pSurface);
++VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, struct ANativeWindow* window, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
++ return GetVtbl(instance).CreateAndroidSurfaceKHR(instance, window, pAllocator, pSurface);
+ }
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index 6aa8673..35d0eaa 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -212,7 +212,7 @@ VkResult EnumerateInstanceExtensionProperties(
+ VkResult EnumerateInstanceLayerProperties(uint32_t* count,
+ VkLayerProperties* properties);
+ VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+- const VkAllocationCallbacks* pAllocator,
++ const VkAllocationCallbacks* allocator,
+ VkInstance* instance);
+ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name);
+ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice drv_device, const char* name);
+@@ -224,7 +224,7 @@ VkResult AllocCommandBuffers(VkDevice device,
+ const VkCommandBufferAllocateInfo* alloc_info,
+ VkCommandBuffer* cmdbufs);
+ VkResult DestroyDevice(VkDevice drv_device,
+- const VkAllocationCallbacks* pAllocator);
++ const VkAllocationCallbacks* allocator);
+
+ void* AllocMem(VkInstance instance,
+ size_t size,
+@@ -261,10 +261,14 @@ bool LoadDeviceVtbl(VkDevice device,
+ // -----------------------------------------------------------------------------
+ // swapchain.cpp
+
+-VKAPI_ATTR VkResult CreateAndroidSurfaceKHR(VkInstance instance,
+- ANativeWindow* window,
+- VkSurfaceKHR* surface);
+-VKAPI_ATTR void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface);
++VKAPI_ATTR VkResult
++CreateAndroidSurfaceKHR(VkInstance instance,
++ ANativeWindow* window,
++ const VkAllocationCallbacks* allocator,
++ VkSurfaceKHR* surface);
++VKAPI_ATTR void DestroySurfaceKHR(VkInstance instance,
++ VkSurfaceKHR surface,
++ const VkAllocationCallbacks* allocator);
+ VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev,
+ uint32_t queue_family,
+ VkSurfaceKHR surface,
+@@ -286,9 +290,11 @@ GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
+ VKAPI_ATTR VkResult
+ CreateSwapchainKHR(VkDevice device,
+ const VkSwapchainCreateInfoKHR* create_info,
++ const VkAllocationCallbacks* allocator,
+ VkSwapchainKHR* swapchain_handle);
+-VKAPI_ATTR VkResult
+-DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain_handle);
++VKAPI_ATTR VkResult DestroySwapchainKHR(VkDevice device,
++ VkSwapchainKHR swapchain_handle,
++ const VkAllocationCallbacks* allocator);
+ VKAPI_ATTR VkResult GetSwapchainImagesKHR(VkDevice device,
+ VkSwapchainKHR swapchain_handle,
+ uint32_t* count,
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index fa5ea59..ee15878 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -144,6 +144,7 @@ namespace vulkan {
+ VKAPI_ATTR
+ VkResult CreateAndroidSurfaceKHR(VkInstance instance,
+ ANativeWindow* window,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkSurfaceKHR* out_surface) {
+ void* mem = AllocMem(instance, sizeof(Surface), alignof(Surface),
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+@@ -171,7 +172,9 @@ VkResult CreateAndroidSurfaceKHR(VkInstance instance,
+ }
+
+ VKAPI_ATTR
+-void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface_handle) {
++void DestroySurfaceKHR(VkInstance instance,
++ VkSurfaceKHR surface_handle,
++ const VkAllocationCallbacks* /*allocator*/) {
+ Surface* surface = SurfaceFromHandle(surface_handle);
+ if (!surface)
+ return;
+@@ -184,8 +187,8 @@ VKAPI_ATTR
+ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
+ uint32_t /*queue_family*/,
+ VkSurfaceKHR /*surface*/,
+- VkBool32* pSupported) {
+- *pSupported = VK_TRUE;
++ VkBool32* supported) {
++ *supported = VK_TRUE;
+ return VK_SUCCESS;
+ }
+
+@@ -296,6 +299,7 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice /*pdev*/,
+ VKAPI_ATTR
+ VkResult CreateSwapchainKHR(VkDevice device,
+ const VkSwapchainCreateInfoKHR* create_info,
++ const VkAllocationCallbacks* /*allocator*/,
+ VkSwapchainKHR* swapchain_handle) {
+ int err;
+ VkResult result = VK_SUCCESS;
+@@ -483,7 +487,9 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ }
+
+ VKAPI_ATTR
+-VkResult DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain_handle) {
++VkResult DestroySwapchainKHR(VkDevice device,
++ VkSwapchainKHR swapchain_handle,
++ const VkAllocationCallbacks* /*allocator*/) {
+ const DeviceVtbl& driver_vtbl = GetDriverVtbl(device);
+ Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
+ const std::shared_ptr<ANativeWindow>& window = swapchain->surface.window;
+--
+2.4.0
+
--- /dev/null
+From 63b94206122e3a7e1175471be20ee22d445ee201 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 30 Nov 2015 14:25:46 -0800
+Subject: [PATCH 26/30] vulkan: Update from version 0.205.0 to 0.206.0
+
+Change-Id: I36370f6ec41abf235975a0c769c03c8f25851d14
+---
+ vulkan/api/vulkan.api | 14 ++++++++------
+ vulkan/include/vulkan/vulkan.h | 40 +++++++++++++++++++++-------------------
+ vulkan/libvulkan/Android.mk | 4 ++++
+ vulkan/libvulkan/swapchain.cpp | 7 -------
+ vulkan/tools/Android.mk | 4 ++++
+ 5 files changed, 37 insertions(+), 32 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 1c4bb8f..73f26e0 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 205
++define VERSION_MINOR 206
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -1293,7 +1293,7 @@ class VkDeviceQueueCreateInfo {
+ const void* pNext /// Pointer to next structure
+ VkDeviceQueueCreateFlags flags
+ u32 queueFamilyIndex
+- u32 queuePriorityCount
++ u32 queueCount
+ const f32* pQueuePriorities
+ }
+
+@@ -1301,8 +1301,8 @@ class VkDeviceCreateInfo {
+ VkStructureType sType /// Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
+ const void* pNext /// Pointer to next structure
+ VkDeviceCreateFlags flags
+- u32 requestedQueueRecordCount
+- const VkDeviceQueueCreateInfo* pRequestedQueues
++ u32 queueCreateInfoCount
++ const VkDeviceQueueCreateInfo* pQueueCreateInfos
+ u32 enabledLayerNameCount
+ const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled
+ u32 enabledExtensionNameCount
+@@ -1642,7 +1642,7 @@ class VkShaderModuleCreateInfo {
+ class VkDescriptorSetLayoutBinding {
+ u32 binding
+ VkDescriptorType descriptorType /// Type of the descriptors in this binding
+- u32 arraySize /// Number of descriptors in this binding
++ u32 descriptorCount /// Number of descriptors in this binding
+ VkShaderStageFlags stageFlags /// Shader stages this binding is visible to
+ const VkSampler* pImmutableSamplers /// Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains <count> number of elements)
+ }
+@@ -2111,6 +2111,7 @@ class VkPhysicalDeviceLimits {
+ u32 maxPerStageDescriptorSampledImages /// max num of sampled images allowed per-stage in a descriptor set
+ u32 maxPerStageDescriptorStorageImages /// max num of storage images allowed per-stage in a descriptor set
+ u32 maxPerStageDescriptorInputAttachments
++ u32 maxPerStageResources
+ u32 maxDescriptorSetSamplers /// max num of samplers allowed in all stages in a descriptor set
+ u32 maxDescriptorSetUniformBuffers /// max num of uniform buffers allowed in all stages in a descriptor set
+ u32 maxDescriptorSetUniformBuffersDynamic /// max num of dynamic uniform buffers allowed in all stages in a descriptor set
+@@ -2156,7 +2157,7 @@ class VkPhysicalDeviceLimits {
+ u32 mipmapPrecisionBits /// num bits of mipmap precision
+
+ u32 maxDrawIndexedIndexValue /// max index value for indexed draw calls (for 32-bit indices)
+- u32 maxDrawIndirectInstanceCount /// max instance count for indirect draw calls
++ u32 maxDrawIndirectCount
+
+ f32 maxSamplerLodBias /// max absolute sampler level of detail bias
+ f32 maxSamplerAnisotropy /// max degree of sampler anisotropy
+@@ -2212,6 +2213,7 @@ class VkPhysicalDeviceLimits {
+
+ VkDeviceSize optimalBufferCopyOffsetAlignment
+ VkDeviceSize optimalBufferCopyRowPitchAlignment
++ VkDeviceSize nonCoherentAtomSize
+ }
+
+ class VkPhysicalDeviceSparseProperties {
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index b342285..ba749a1 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 205, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 206, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -125,6 +125,12 @@ typedef enum VkResult {
+ VK_ERROR_INCOMPATIBLE_DRIVER = -9,
+ VK_ERROR_TOO_MANY_OBJECTS = -10,
+ VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
++ VK_ERROR_SURFACE_LOST_KHR = 0xC0000400,
++ VK_SUBOPTIMAL_KHR = 0x40000403,
++ VK_ERROR_OUT_OF_DATE_KHR = 0xC0000804,
++ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC0001002,
++ VK_ERROR_INVALID_ANDROID_WINDOW_KHR = 0xC0002400,
++ VK_ERROR_ANDROID_WINDOW_IN_USE_KHR = 0xC0002401,
+ VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED,
+ VK_RESULT_END_RANGE = VK_INCOMPLETE,
+ VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + 1),
+@@ -180,6 +186,12 @@ typedef enum VkStructureType {
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45,
+ VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 46,
+ VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 47,
++ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 0xC0000800,
++ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 0xC0000801,
++ VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 0xC0000C00,
++ VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 0xC0000C01,
++ VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR = 0xC0001000,
++ VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 0xC0001001,
+ VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+ VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO,
+ VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+@@ -447,6 +459,7 @@ typedef enum VkImageLayout {
+ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
+ VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
++ VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 0xC0000802,
+ VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
+ VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
+ VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
+@@ -1204,6 +1217,7 @@ typedef struct VkPhysicalDeviceLimits {
+ uint32_t maxPerStageDescriptorSampledImages;
+ uint32_t maxPerStageDescriptorStorageImages;
+ uint32_t maxPerStageDescriptorInputAttachments;
++ uint32_t maxPerStageResources;
+ uint32_t maxDescriptorSetSamplers;
+ uint32_t maxDescriptorSetUniformBuffers;
+ uint32_t maxDescriptorSetUniformBuffersDynamic;
+@@ -1242,7 +1256,7 @@ typedef struct VkPhysicalDeviceLimits {
+ uint32_t subTexelPrecisionBits;
+ uint32_t mipmapPrecisionBits;
+ uint32_t maxDrawIndexedIndexValue;
+- uint32_t maxDrawIndirectInstanceCount;
++ uint32_t maxDrawIndirectCount;
+ float maxSamplerLodBias;
+ float maxSamplerAnisotropy;
+ uint32_t maxViewports;
+@@ -1287,6 +1301,7 @@ typedef struct VkPhysicalDeviceLimits {
+ VkBool32 standardSampleLocations;
+ VkDeviceSize optimalBufferCopyOffsetAlignment;
+ VkDeviceSize optimalBufferCopyRowPitchAlignment;
++ VkDeviceSize nonCoherentAtomSize;
+ } VkPhysicalDeviceLimits;
+
+ typedef struct VkPhysicalDeviceSparseProperties {
+@@ -1338,7 +1353,7 @@ typedef struct VkDeviceQueueCreateInfo {
+ const void* pNext;
+ VkDeviceQueueCreateFlags flags;
+ uint32_t queueFamilyIndex;
+- uint32_t queuePriorityCount;
++ uint32_t queueCount;
+ const float* pQueuePriorities;
+ } VkDeviceQueueCreateInfo;
+
+@@ -1346,8 +1361,8 @@ typedef struct VkDeviceCreateInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceCreateFlags flags;
+- uint32_t requestedQueueCount;
+- const VkDeviceQueueCreateInfo* pRequestedQueues;
++ uint32_t queueCreateInfoCount;
++ const VkDeviceQueueCreateInfo* pQueueCreateInfos;
+ uint32_t enabledLayerNameCount;
+ const char*const* ppEnabledLayerNames;
+ uint32_t enabledExtensionNameCount;
+@@ -1839,7 +1854,7 @@ typedef struct VkSamplerCreateInfo {
+ typedef struct VkDescriptorSetLayoutBinding {
+ uint32_t binding;
+ VkDescriptorType descriptorType;
+- uint32_t arraySize;
++ uint32_t descriptorCount;
+ VkShaderStageFlags stageFlags;
+ const VkSampler* pImmutableSamplers;
+ } VkDescriptorSetLayoutBinding;
+@@ -3071,7 +3086,6 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
+ #define VK_KHR_SURFACE_REVISION 23
+ #define VK_KHR_SURFACE_EXTENSION_NUMBER 1
+ #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"
+-#define VK_ERROR_SURFACE_LOST_KHR ((VkResult)(int)0xc0000400)
+
+
+ typedef enum VkSurfaceTransformKHR {
+@@ -3192,11 +3206,6 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
+ #define VK_KHR_SWAPCHAIN_REVISION 66
+ #define VK_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+ #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
+-#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
+-#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801)
+-#define VK_IMAGE_LAYOUT_PRESENT_SRC_KHR ((VkImageLayout)(int)0xc0000802)
+-#define VK_SUBOPTIMAL_KHR ((VkResult)(int)0x40000403)
+-#define VK_ERROR_OUT_OF_DATE_KHR ((VkResult)(int)0xc0000804)
+
+ typedef struct VkSwapchainCreateInfoKHR {
+ VkStructureType sType;
+@@ -3274,8 +3283,6 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
+ #define VK_KHR_DISPLAY_REVISION 19
+ #define VK_KHR_DISPLAY_EXTENSION_NUMBER 3
+ #define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"
+-#define VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c00)
+-#define VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000c01)
+
+
+ typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
+@@ -3395,9 +3402,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
+ #define VK_KHR_DISPLAY_SWAPCHAIN_REVISION 8
+ #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4
+ #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
+-#define VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0001000)
+-#define VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0001001)
+-#define VK_ERROR_INCOMPATIBLE_DISPLAY_KHR ((VkResult)(int)0xc0001002)
+
+ typedef struct VkDisplaySwapchainCreateInfoKHR {
+ VkStructureType sType;
+@@ -3528,8 +3532,6 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
+ #define VK_KHR_ANDROID_SURFACE_REVISION 3
+ #define VK_KHR_ANDROID_SURFACE_EXTENSION_NUMBER 9
+ #define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
+-#define VK_ERROR_INVALID_ANDROID_WINDOW_KHR ((VkResult)(int)0xc0002400)
+-#define VK_ERROR_ANDROID_WINDOW_IN_USE_KHR ((VkResult)(int)0xc0002401)
+
+ typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, ANativeWindow* window, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+diff --git a/vulkan/libvulkan/Android.mk b/vulkan/libvulkan/Android.mk
+index 7a2eb64..2f809c2 100644
+--- a/vulkan/libvulkan/Android.mk
++++ b/vulkan/libvulkan/Android.mk
+@@ -25,6 +25,10 @@ LOCAL_CPPFLAGS := -std=c++1y \
+ -Wno-c99-extensions \
+ -Wno-zero-length-array
+
++# TODO(jessehall): Very temporary, until VkResult values are defined as signed integers
++# rather than unsigned hex values.
++LOCAL_CFLAGS += -Wno-error=format
++
+ LOCAL_C_INCLUDES := \
+ frameworks/native/vulkan/include \
+ system/core/libsync/include
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index ee15878..ff02b35 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -569,10 +569,7 @@ VkResult AcquireNextImageKHR(VkDevice device,
+ if (idx == swapchain.num_images) {
+ ALOGE("dequeueBuffer returned unrecognized buffer");
+ window->cancelBuffer(window, buffer, fence);
+-#pragma clang diagnostic push
+-#pragma clang diagnostic ignored "-Wold-style-cast"
+ return VK_ERROR_OUT_OF_DATE_KHR;
+-#pragma clang diagnostic pop
+ }
+
+ int fence_clone = -1;
+@@ -616,13 +613,9 @@ VkResult AcquireNextImageKHR(VkDevice device,
+
+ VKAPI_ATTR
+ VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info) {
+-#pragma clang diagnostic push
+-#pragma clang diagnostic ignored "-Wold-style-cast"
+-#pragma clang diagnostic ignored "-Wsign-conversion"
+ ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+ "vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",
+ present_info->sType);
+-#pragma clang diagnostic pop
+ ALOGV_IF(present_info->pNext, "VkPresentInfo::pNext != NULL");
+
+ const DeviceVtbl& driver_vtbl = GetDriverVtbl(queue);
+diff --git a/vulkan/tools/Android.mk b/vulkan/tools/Android.mk
+index 31d6089..2c2309f 100644
+--- a/vulkan/tools/Android.mk
++++ b/vulkan/tools/Android.mk
+@@ -23,6 +23,10 @@ LOCAL_CPPFLAGS := -std=c++1y \
+ -Wno-c++98-compat-pedantic \
+ -Wno-c99-extensions
+
++# TODO(jessehall): Very temporary, until VkResult values are defined as signed integers
++# rather than unsigned hex values.
++LOCAL_CFLAGS += -Wno-error=format
++
+ LOCAL_C_INCLUDES := \
+ frameworks/native/vulkan/include
+
+--
+2.4.0
+
--- /dev/null
+From 6b46fedd72f5168b95519afeeeb74c92c663affe Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 30 Nov 2015 16:04:55 -0800
+Subject: [PATCH 27/30] vulkan: Update from version 0.206.0 to 0.209.0
+
+Change-Id: Ieaf1c4c01f3376cde407bef193a9aa33e77ca123
+---
+ vulkan/api/vulkan.api | 459 +++++++++++++++++++++--------------------
+ vulkan/include/vulkan/vulkan.h | 437 ++++++++++++++++++++-------------------
+ vulkan/libvulkan/entry.cpp | 6 +-
+ vulkan/libvulkan/loader.h | 2 +-
+ vulkan/libvulkan/swapchain.cpp | 16 +-
+ 5 files changed, 469 insertions(+), 451 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 73f26e0..d35e11d 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 206
++define VERSION_MINOR 209
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -45,15 +45,15 @@ define VK_FALSE 0
+ // API keyword, but needs special handling by some templates
+ define NULL_HANDLE 0
+
+-@extension("VK_KHR_surface") define VK_KHR_SURFACE_REVISION 23
++@extension("VK_KHR_surface") define VK_KHR_SURFACE_REVISION 24
+ @extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NUMBER 1
+ @extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"
+
+-@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_REVISION 66
++@extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_REVISION 67
+ @extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+ @extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
+
+-@extension("VK_KHR_display") define VK_KHR_DISPLAY_REVISION 19
++@extension("VK_KHR_display") define VK_KHR_DISPLAY_REVISION 21
+ @extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NUMBER 3
+ @extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"
+
+@@ -77,7 +77,7 @@ define NULL_HANDLE 0
+ @extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_NUMBER 8
+ @extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_NAME "VK_KHR_mir_surface"
+
+-@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_REVISION 3
++@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_REVISION 4
+ @extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_NUMBER 8
+ @extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_NAME "VK_KHR_android_surface"
+
+@@ -384,180 +384,191 @@ enum VkVertexInputRate {
+
+ /// Vulkan format definitions
+ enum VkFormat {
+- VK_FORMAT_UNDEFINED = 0x00000000,
+- VK_FORMAT_R4G4_UNORM = 0x00000001,
+- VK_FORMAT_R4G4_USCALED = 0x00000002,
+- VK_FORMAT_R4G4B4A4_UNORM = 0x00000003,
+- VK_FORMAT_R4G4B4A4_USCALED = 0x00000004,
+- VK_FORMAT_R5G6B5_UNORM = 0x00000005,
+- VK_FORMAT_R5G6B5_USCALED = 0x00000006,
+- VK_FORMAT_R5G5B5A1_UNORM = 0x00000007,
+- VK_FORMAT_R5G5B5A1_USCALED = 0x00000008,
+- VK_FORMAT_R8_UNORM = 0x00000009,
+- VK_FORMAT_R8_SNORM = 0x0000000A,
+- VK_FORMAT_R8_USCALED = 0x0000000B,
+- VK_FORMAT_R8_SSCALED = 0x0000000C,
+- VK_FORMAT_R8_UINT = 0x0000000D,
+- VK_FORMAT_R8_SINT = 0x0000000E,
+- VK_FORMAT_R8_SRGB = 0x0000000F,
+- VK_FORMAT_R8G8_UNORM = 0x00000010,
+- VK_FORMAT_R8G8_SNORM = 0x00000011,
+- VK_FORMAT_R8G8_USCALED = 0x00000012,
+- VK_FORMAT_R8G8_SSCALED = 0x00000013,
+- VK_FORMAT_R8G8_UINT = 0x00000014,
+- VK_FORMAT_R8G8_SINT = 0x00000015,
+- VK_FORMAT_R8G8_SRGB = 0x00000016,
+- VK_FORMAT_R8G8B8_UNORM = 0x00000017,
+- VK_FORMAT_R8G8B8_SNORM = 0x00000018,
+- VK_FORMAT_R8G8B8_USCALED = 0x00000019,
+- VK_FORMAT_R8G8B8_SSCALED = 0x0000001A,
+- VK_FORMAT_R8G8B8_UINT = 0x0000001B,
+- VK_FORMAT_R8G8B8_SINT = 0x0000001C,
+- VK_FORMAT_R8G8B8_SRGB = 0x0000001D,
+- VK_FORMAT_R8G8B8A8_UNORM = 0x0000001E,
+- VK_FORMAT_R8G8B8A8_SNORM = 0x0000001F,
+- VK_FORMAT_R8G8B8A8_USCALED = 0x00000020,
+- VK_FORMAT_R8G8B8A8_SSCALED = 0x00000021,
+- VK_FORMAT_R8G8B8A8_UINT = 0x00000022,
+- VK_FORMAT_R8G8B8A8_SINT = 0x00000023,
+- VK_FORMAT_R8G8B8A8_SRGB = 0x00000024,
+- VK_FORMAT_R10G10B10A2_UNORM = 0x00000025,
+- VK_FORMAT_R10G10B10A2_SNORM = 0x00000026,
+- VK_FORMAT_R10G10B10A2_USCALED = 0x00000027,
+- VK_FORMAT_R10G10B10A2_SSCALED = 0x00000028,
+- VK_FORMAT_R10G10B10A2_UINT = 0x00000029,
+- VK_FORMAT_R10G10B10A2_SINT = 0x0000002A,
+- VK_FORMAT_R16_UNORM = 0x0000002B,
+- VK_FORMAT_R16_SNORM = 0x0000002C,
+- VK_FORMAT_R16_USCALED = 0x0000002D,
+- VK_FORMAT_R16_SSCALED = 0x0000002E,
+- VK_FORMAT_R16_UINT = 0x0000002F,
+- VK_FORMAT_R16_SINT = 0x00000030,
+- VK_FORMAT_R16_SFLOAT = 0x00000031,
+- VK_FORMAT_R16G16_UNORM = 0x00000032,
+- VK_FORMAT_R16G16_SNORM = 0x00000033,
+- VK_FORMAT_R16G16_USCALED = 0x00000034,
+- VK_FORMAT_R16G16_SSCALED = 0x00000035,
+- VK_FORMAT_R16G16_UINT = 0x00000036,
+- VK_FORMAT_R16G16_SINT = 0x00000037,
+- VK_FORMAT_R16G16_SFLOAT = 0x00000038,
+- VK_FORMAT_R16G16B16_UNORM = 0x00000039,
+- VK_FORMAT_R16G16B16_SNORM = 0x0000003A,
+- VK_FORMAT_R16G16B16_USCALED = 0x0000003B,
+- VK_FORMAT_R16G16B16_SSCALED = 0x0000003C,
+- VK_FORMAT_R16G16B16_UINT = 0x0000003D,
+- VK_FORMAT_R16G16B16_SINT = 0x0000003E,
+- VK_FORMAT_R16G16B16_SFLOAT = 0x0000003F,
+- VK_FORMAT_R16G16B16A16_UNORM = 0x00000040,
+- VK_FORMAT_R16G16B16A16_SNORM = 0x00000041,
+- VK_FORMAT_R16G16B16A16_USCALED = 0x00000042,
+- VK_FORMAT_R16G16B16A16_SSCALED = 0x00000043,
+- VK_FORMAT_R16G16B16A16_UINT = 0x00000044,
+- VK_FORMAT_R16G16B16A16_SINT = 0x00000045,
+- VK_FORMAT_R16G16B16A16_SFLOAT = 0x00000046,
+- VK_FORMAT_R32_UINT = 0x00000047,
+- VK_FORMAT_R32_SINT = 0x00000048,
+- VK_FORMAT_R32_SFLOAT = 0x00000049,
+- VK_FORMAT_R32G32_UINT = 0x0000004A,
+- VK_FORMAT_R32G32_SINT = 0x0000004B,
+- VK_FORMAT_R32G32_SFLOAT = 0x0000004C,
+- VK_FORMAT_R32G32B32_UINT = 0x0000004D,
+- VK_FORMAT_R32G32B32_SINT = 0x0000004E,
+- VK_FORMAT_R32G32B32_SFLOAT = 0x0000004F,
+- VK_FORMAT_R32G32B32A32_UINT = 0x00000050,
+- VK_FORMAT_R32G32B32A32_SINT = 0x00000051,
+- VK_FORMAT_R32G32B32A32_SFLOAT = 0x00000052,
+- VK_FORMAT_R64_SFLOAT = 0x00000053,
+- VK_FORMAT_R64G64_SFLOAT = 0x00000054,
+- VK_FORMAT_R64G64B64_SFLOAT = 0x00000055,
+- VK_FORMAT_R64G64B64A64_SFLOAT = 0x00000056,
+- VK_FORMAT_R11G11B10_UFLOAT = 0x00000057,
+- VK_FORMAT_R9G9B9E5_UFLOAT = 0x00000058,
+- VK_FORMAT_D16_UNORM = 0x00000059,
+- VK_FORMAT_D24_UNORM_X8 = 0x0000005A,
+- VK_FORMAT_D32_SFLOAT = 0x0000005B,
+- VK_FORMAT_S8_UINT = 0x0000005C,
+- VK_FORMAT_D16_UNORM_S8_UINT = 0x0000005D,
+- VK_FORMAT_D24_UNORM_S8_UINT = 0x0000005E,
+- VK_FORMAT_D32_SFLOAT_S8_UINT = 0x0000005F,
+- VK_FORMAT_BC1_RGB_UNORM = 0x00000060,
+- VK_FORMAT_BC1_RGB_SRGB = 0x00000061,
+- VK_FORMAT_BC1_RGBA_UNORM = 0x00000062,
+- VK_FORMAT_BC1_RGBA_SRGB = 0x00000063,
+- VK_FORMAT_BC2_UNORM = 0x00000064,
+- VK_FORMAT_BC2_SRGB = 0x00000065,
+- VK_FORMAT_BC3_UNORM = 0x00000066,
+- VK_FORMAT_BC3_SRGB = 0x00000067,
+- VK_FORMAT_BC4_UNORM = 0x00000068,
+- VK_FORMAT_BC4_SNORM = 0x00000069,
+- VK_FORMAT_BC5_UNORM = 0x0000006A,
+- VK_FORMAT_BC5_SNORM = 0x0000006B,
+- VK_FORMAT_BC6H_UFLOAT = 0x0000006C,
+- VK_FORMAT_BC6H_SFLOAT = 0x0000006D,
+- VK_FORMAT_BC7_UNORM = 0x0000006E,
+- VK_FORMAT_BC7_SRGB = 0x0000006F,
+- VK_FORMAT_ETC2_R8G8B8_UNORM = 0x00000070,
+- VK_FORMAT_ETC2_R8G8B8_SRGB = 0x00000071,
+- VK_FORMAT_ETC2_R8G8B8A1_UNORM = 0x00000072,
+- VK_FORMAT_ETC2_R8G8B8A1_SRGB = 0x00000073,
+- VK_FORMAT_ETC2_R8G8B8A8_UNORM = 0x00000074,
+- VK_FORMAT_ETC2_R8G8B8A8_SRGB = 0x00000075,
+- VK_FORMAT_EAC_R11_UNORM = 0x00000076,
+- VK_FORMAT_EAC_R11_SNORM = 0x00000077,
+- VK_FORMAT_EAC_R11G11_UNORM = 0x00000078,
+- VK_FORMAT_EAC_R11G11_SNORM = 0x00000079,
+- VK_FORMAT_ASTC_4x4_UNORM = 0x0000007A,
+- VK_FORMAT_ASTC_4x4_SRGB = 0x0000007B,
+- VK_FORMAT_ASTC_5x4_UNORM = 0x0000007C,
+- VK_FORMAT_ASTC_5x4_SRGB = 0x0000007D,
+- VK_FORMAT_ASTC_5x5_UNORM = 0x0000007E,
+- VK_FORMAT_ASTC_5x5_SRGB = 0x0000007F,
+- VK_FORMAT_ASTC_6x5_UNORM = 0x00000080,
+- VK_FORMAT_ASTC_6x5_SRGB = 0x00000081,
+- VK_FORMAT_ASTC_6x6_UNORM = 0x00000082,
+- VK_FORMAT_ASTC_6x6_SRGB = 0x00000083,
+- VK_FORMAT_ASTC_8x5_UNORM = 0x00000084,
+- VK_FORMAT_ASTC_8x5_SRGB = 0x00000085,
+- VK_FORMAT_ASTC_8x6_UNORM = 0x00000086,
+- VK_FORMAT_ASTC_8x6_SRGB = 0x00000087,
+- VK_FORMAT_ASTC_8x8_UNORM = 0x00000088,
+- VK_FORMAT_ASTC_8x8_SRGB = 0x00000089,
+- VK_FORMAT_ASTC_10x5_UNORM = 0x0000008A,
+- VK_FORMAT_ASTC_10x5_SRGB = 0x0000008B,
+- VK_FORMAT_ASTC_10x6_UNORM = 0x0000008C,
+- VK_FORMAT_ASTC_10x6_SRGB = 0x0000008D,
+- VK_FORMAT_ASTC_10x8_UNORM = 0x0000008E,
+- VK_FORMAT_ASTC_10x8_SRGB = 0x0000008F,
+- VK_FORMAT_ASTC_10x10_UNORM = 0x00000090,
+- VK_FORMAT_ASTC_10x10_SRGB = 0x00000091,
+- VK_FORMAT_ASTC_12x10_UNORM = 0x00000092,
+- VK_FORMAT_ASTC_12x10_SRGB = 0x00000093,
+- VK_FORMAT_ASTC_12x12_UNORM = 0x00000094,
+- VK_FORMAT_ASTC_12x12_SRGB = 0x00000095,
+- VK_FORMAT_B4G4R4A4_UNORM = 0x00000096,
+- VK_FORMAT_B5G5R5A1_UNORM = 0x00000097,
+- VK_FORMAT_B5G6R5_UNORM = 0x00000098,
+- VK_FORMAT_B5G6R5_USCALED = 0x00000099,
+- VK_FORMAT_B8G8R8_UNORM = 0x0000009A,
+- VK_FORMAT_B8G8R8_SNORM = 0x0000009B,
+- VK_FORMAT_B8G8R8_USCALED = 0x0000009C,
+- VK_FORMAT_B8G8R8_SSCALED = 0x0000009D,
+- VK_FORMAT_B8G8R8_UINT = 0x0000009E,
+- VK_FORMAT_B8G8R8_SINT = 0x0000009F,
+- VK_FORMAT_B8G8R8_SRGB = 0x000000A0,
+- VK_FORMAT_B8G8R8A8_UNORM = 0x000000A1,
+- VK_FORMAT_B8G8R8A8_SNORM = 0x000000A2,
+- VK_FORMAT_B8G8R8A8_USCALED = 0x000000A3,
+- VK_FORMAT_B8G8R8A8_SSCALED = 0x000000A4,
+- VK_FORMAT_B8G8R8A8_UINT = 0x000000A5,
+- VK_FORMAT_B8G8R8A8_SINT = 0x000000A6,
+- VK_FORMAT_B8G8R8A8_SRGB = 0x000000A7,
+- VK_FORMAT_B10G10R10A2_UNORM = 0x000000A8,
+- VK_FORMAT_B10G10R10A2_SNORM = 0x000000A9,
+- VK_FORMAT_B10G10R10A2_USCALED = 0x000000AA,
+- VK_FORMAT_B10G10R10A2_SSCALED = 0x000000AB,
+- VK_FORMAT_B10G10R10A2_UINT = 0x000000AC,
+- VK_FORMAT_B10G10R10A2_SINT = 0x000000AD,
++ VK_FORMAT_UNDEFINED = 0,
++ VK_FORMAT_R4G4_UNORM_PACK8 = 1,
++ VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
++ VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
++ VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
++ VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
++ VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
++ VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
++ VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
++ VK_FORMAT_R8_UNORM = 9,
++ VK_FORMAT_R8_SNORM = 10,
++ VK_FORMAT_R8_USCALED = 11,
++ VK_FORMAT_R8_SSCALED = 12,
++ VK_FORMAT_R8_UINT = 13,
++ VK_FORMAT_R8_SINT = 14,
++ VK_FORMAT_R8_SRGB = 15,
++ VK_FORMAT_R8G8_UNORM = 16,
++ VK_FORMAT_R8G8_SNORM = 17,
++ VK_FORMAT_R8G8_USCALED = 18,
++ VK_FORMAT_R8G8_SSCALED = 19,
++ VK_FORMAT_R8G8_UINT = 20,
++ VK_FORMAT_R8G8_SINT = 21,
++ VK_FORMAT_R8G8_SRGB = 22,
++ VK_FORMAT_R8G8B8_UNORM = 23,
++ VK_FORMAT_R8G8B8_SNORM = 24,
++ VK_FORMAT_R8G8B8_USCALED = 25,
++ VK_FORMAT_R8G8B8_SSCALED = 26,
++ VK_FORMAT_R8G8B8_UINT = 27,
++ VK_FORMAT_R8G8B8_SINT = 28,
++ VK_FORMAT_R8G8B8_SRGB = 29,
++ VK_FORMAT_B8G8R8_UNORM = 30,
++ VK_FORMAT_B8G8R8_SNORM = 31,
++ VK_FORMAT_B8G8R8_USCALED = 32,
++ VK_FORMAT_B8G8R8_SSCALED = 33,
++ VK_FORMAT_B8G8R8_UINT = 34,
++ VK_FORMAT_B8G8R8_SINT = 35,
++ VK_FORMAT_B8G8R8_SRGB = 36,
++ VK_FORMAT_R8G8B8A8_UNORM = 37,
++ VK_FORMAT_R8G8B8A8_SNORM = 38,
++ VK_FORMAT_R8G8B8A8_USCALED = 39,
++ VK_FORMAT_R8G8B8A8_SSCALED = 40,
++ VK_FORMAT_R8G8B8A8_UINT = 41,
++ VK_FORMAT_R8G8B8A8_SINT = 42,
++ VK_FORMAT_R8G8B8A8_SRGB = 43,
++ VK_FORMAT_B8G8R8A8_UNORM = 44,
++ VK_FORMAT_B8G8R8A8_SNORM = 45,
++ VK_FORMAT_B8G8R8A8_USCALED = 46,
++ VK_FORMAT_B8G8R8A8_SSCALED = 47,
++ VK_FORMAT_B8G8R8A8_UINT = 48,
++ VK_FORMAT_B8G8R8A8_SINT = 49,
++ VK_FORMAT_B8G8R8A8_SRGB = 50,
++ VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
++ VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
++ VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
++ VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
++ VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
++ VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
++ VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
++ VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
++ VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
++ VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
++ VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
++ VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
++ VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
++ VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
++ VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
++ VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
++ VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
++ VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
++ VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
++ VK_FORMAT_R16_UNORM = 70,
++ VK_FORMAT_R16_SNORM = 71,
++ VK_FORMAT_R16_USCALED = 72,
++ VK_FORMAT_R16_SSCALED = 73,
++ VK_FORMAT_R16_UINT = 74,
++ VK_FORMAT_R16_SINT = 75,
++ VK_FORMAT_R16_SFLOAT = 76,
++ VK_FORMAT_R16G16_UNORM = 77,
++ VK_FORMAT_R16G16_SNORM = 78,
++ VK_FORMAT_R16G16_USCALED = 79,
++ VK_FORMAT_R16G16_SSCALED = 80,
++ VK_FORMAT_R16G16_UINT = 81,
++ VK_FORMAT_R16G16_SINT = 82,
++ VK_FORMAT_R16G16_SFLOAT = 83,
++ VK_FORMAT_R16G16B16_UNORM = 84,
++ VK_FORMAT_R16G16B16_SNORM = 85,
++ VK_FORMAT_R16G16B16_USCALED = 86,
++ VK_FORMAT_R16G16B16_SSCALED = 87,
++ VK_FORMAT_R16G16B16_UINT = 88,
++ VK_FORMAT_R16G16B16_SINT = 89,
++ VK_FORMAT_R16G16B16_SFLOAT = 90,
++ VK_FORMAT_R16G16B16A16_UNORM = 91,
++ VK_FORMAT_R16G16B16A16_SNORM = 92,
++ VK_FORMAT_R16G16B16A16_USCALED = 93,
++ VK_FORMAT_R16G16B16A16_SSCALED = 94,
++ VK_FORMAT_R16G16B16A16_UINT = 95,
++ VK_FORMAT_R16G16B16A16_SINT = 96,
++ VK_FORMAT_R16G16B16A16_SFLOAT = 97,
++ VK_FORMAT_R32_UINT = 98,
++ VK_FORMAT_R32_SINT = 99,
++ VK_FORMAT_R32_SFLOAT = 100,
++ VK_FORMAT_R32G32_UINT = 101,
++ VK_FORMAT_R32G32_SINT = 102,
++ VK_FORMAT_R32G32_SFLOAT = 103,
++ VK_FORMAT_R32G32B32_UINT = 104,
++ VK_FORMAT_R32G32B32_SINT = 105,
++ VK_FORMAT_R32G32B32_SFLOAT = 106,
++ VK_FORMAT_R32G32B32A32_UINT = 107,
++ VK_FORMAT_R32G32B32A32_SINT = 108,
++ VK_FORMAT_R32G32B32A32_SFLOAT = 109,
++ VK_FORMAT_R64_UINT = 110,
++ VK_FORMAT_R64_SINT = 111,
++ VK_FORMAT_R64_SFLOAT = 112,
++ VK_FORMAT_R64G64_UINT = 113,
++ VK_FORMAT_R64G64_SINT = 114,
++ VK_FORMAT_R64G64_SFLOAT = 115,
++ VK_FORMAT_R64G64B64_UINT = 116,
++ VK_FORMAT_R64G64B64_SINT = 117,
++ VK_FORMAT_R64G64B64_SFLOAT = 118,
++ VK_FORMAT_R64G64B64A64_UINT = 119,
++ VK_FORMAT_R64G64B64A64_SINT = 120,
++ VK_FORMAT_R64G64B64A64_SFLOAT = 121,
++ VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
++ VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
++ VK_FORMAT_D16_UNORM = 124,
++ VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
++ VK_FORMAT_D32_SFLOAT = 126,
++ VK_FORMAT_S8_UINT = 127,
++ VK_FORMAT_D16_UNORM_S8_UINT = 128,
++ VK_FORMAT_D24_UNORM_S8_UINT = 129,
++ VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
++ VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
++ VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
++ VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
++ VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
++ VK_FORMAT_BC2_UNORM_BLOCK = 135,
++ VK_FORMAT_BC2_SRGB_BLOCK = 136,
++ VK_FORMAT_BC3_UNORM_BLOCK = 137,
++ VK_FORMAT_BC3_SRGB_BLOCK = 138,
++ VK_FORMAT_BC4_UNORM_BLOCK = 139,
++ VK_FORMAT_BC4_SNORM_BLOCK = 140,
++ VK_FORMAT_BC5_UNORM_BLOCK = 141,
++ VK_FORMAT_BC5_SNORM_BLOCK = 142,
++ VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
++ VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
++ VK_FORMAT_BC7_UNORM_BLOCK = 145,
++ VK_FORMAT_BC7_SRGB_BLOCK = 146,
++ VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
++ VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
++ VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
++ VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
++ VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
++ VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
++ VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
++ VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
++ VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
++ VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
++ VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
++ VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
++ VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
++ VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
++ VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
++ VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
++ VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
++ VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
++ VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
++ VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
++ VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
++ VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
++ VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
++ VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
++ VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
++ VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
++ VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
++ VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
++ VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
++ VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
++ VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
++ VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
++ VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
++ VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
++ VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
++ VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
++ VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
++ VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
+ }
+
+ /// Structure type enumerant
+@@ -567,7 +578,7 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
+ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
+ VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
+- VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 5,
++ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
+ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
+ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
+ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
+@@ -596,20 +607,20 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 34,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
+ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
+ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
+ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
+- VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 40,
++ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 41,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 42,
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43,
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44,
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45,
+- VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 46,
+- VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 47,
++ VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 46,
++ VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 47,
+
+ //@extension("VK_KHR_swapchain")
+ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 0xc0000801,
+@@ -665,8 +676,7 @@ enum VkResult {
+ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC0001002,
+
+ //@extension("VK_KHR_android_surface")
+- VK_ERROR_INVALID_ANDROID_WINDOW_KHR = 0xC002400,
+- VK_ERROR_ANDROID_WINDOW_IN_USE_KHR = 0xC002401,
++ VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = 0xC0002400,
+ }
+
+ enum VkDynamicState {
+@@ -681,19 +691,6 @@ enum VkDynamicState {
+ VK_DYNAMIC_STATE_STENCIL_REFERENCE = 0x00000008,
+ }
+
+-@extension("VK_KHR_surface")
+-enum VkSurfaceTransformKHR {
+- VK_SURFACE_TRANSFORM_NONE_KHR = 0x00000000,
+- VK_SURFACE_TRANSFORM_ROT90_KHR = 0x00000001,
+- VK_SURFACE_TRANSFORM_ROT180_KHR = 0x00000002,
+- VK_SURFACE_TRANSFORM_ROT270_KHR = 0x00000003,
+- VK_SURFACE_TRANSFORM_HMIRROR_KHR = 0x00000004,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT90_KHR = 0x00000005,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT180_KHR = 0x00000006,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT270_KHR = 0x00000007,
+- VK_SURFACE_TRANSFORM_INHERIT_KHR = 0x00000008,
+-}
+-
+ @extension("VK_KHR_swapchain")
+ enum VkPresentModeKHR {
+ VK_PRESENT_MODE_IMMEDIATE_KHR = 0x00000000,
+@@ -1171,15 +1168,28 @@ bitfield VkCompositeAlphaFlagBitsKHR {
+ VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
+ }
+
++@extension("VK_KHR_swapchain")
++type VkFlags VkSwapchainCreateFlagsKHR
++//@extension("VK_KHR_swapchain")
++//bitfield VkSwapchainCreateFlagBitsKHR {
++//}
++
+ @extension("VK_KHR_display")
+ type VkFlags VkDisplayPlaneAlphaFlagsKHR
+ @extension("VK_KHR_display")
+ bitfield VkDisplayPlaneAlphaFlagBitsKHR {
+- VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000001,
+- VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000002,
+- VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000004,
++ VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
++ VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
++ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
++ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
+ }
+
++@extension("VK_KHR_display")
++type VkFlags VkDisplaySurfaceCreateFlagsKHR
++//@extension("VK_KHR_display")
++//bitfield VkDisplaySurfaceCreateFlagBitsKHR {
++//}
++
+
+ //////////////////
+ // Structures //
+@@ -1336,7 +1346,7 @@ class VkPhysicalDeviceMemoryProperties {
+ }
+
+ class VkMemoryAllocateInfo {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
+ const void* pNext /// Pointer to next structure
+ VkDeviceSize allocationSize /// Size of memory allocation
+ u32 memoryTypeIndex /// Index of the of the memory type to allocate from
+@@ -1670,7 +1680,7 @@ class VkDescriptorPoolCreateInfo {
+ }
+
+ class VkDescriptorSetAllocateInfo {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
+ const void* pNext /// Pointer to next structure
+ VkDescriptorPool descriptorPool
+ u32 setCount
+@@ -1915,7 +1925,7 @@ class VkCommandPoolCreateInfo {
+ }
+
+ class VkCommandBufferAllocateInfo {
+- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO
++ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
+ const void* pNext /// Pointer to next structure
+ VkCommandPool commandPool
+ VkCommandBufferLevel level
+@@ -1929,6 +1939,9 @@ class VkCommandBufferBeginInfo {
+ VkRenderPass renderPass /// Render pass for secondary command buffers
+ u32 subpass
+ VkFramebuffer framebuffer /// Framebuffer for secondary command buffers
++ VkBool32 occlusionQueryEnable
++ VkQueryControlFlags queryFlags
++ VkQueryPipelineStatisticFlags pipelineStatistics
+ }
+
+ class VkRenderPassBeginInfo {
+@@ -2279,10 +2292,10 @@ class VkSurfaceCapabilitiesKHR {
+ VkExtent2D currentExtent
+ VkExtent2D minImageExtent
+ VkExtent2D maxImageExtent
++ u32 maxImageArrayLayers
+ VkSurfaceTransformFlagsKHR supportedTransforms
+- VkSurfaceTransformKHR currentTransform
++ VkSurfaceTransformFlagBitsKHR currentTransform
+ VkCompositeAlphaFlagsKHR supportedCompositeAlpha
+- u32 maxImageArraySize
+ VkImageUsageFlags supportedUsageFlags
+ }
+
+@@ -2296,21 +2309,22 @@ class VkSurfaceFormatKHR {
+ class VkSwapchainCreateInfoKHR {
+ VkStructureType sType
+ const void* pNext
++ VkSwapchainCreateFlagsKHR flags
+ VkSurfaceKHR surface
+ u32 minImageCount
+ VkFormat imageFormat
+ VkColorSpaceKHR imageColorSpace
+ VkExtent2D imageExtent
+- VkImageUsageFlags imageUsageFlags
+- VkSurfaceTransformKHR preTransform
+- VkCompositeAlphaFlagBitsKHR compositeAlpha
+- u32 imageArraySize
++ u32 imageArrayLayers
++ VkImageUsageFlags imageUsage
+ VkSharingMode sharingMode
+ u32 queueFamilyIndexCount
+ const u32* pQueueFamilyIndices
++ VkSurfaceTransformFlagBitsKHR preTransform
++ VkCompositeAlphaFlagBitsKHR compositeAlpha
+ VkPresentModeKHR presentMode
+- VkSwapchainKHR oldSwapchain
+ VkBool32 clipped
++ VkSwapchainKHR oldSwapchain
+ }
+
+ @extension("VK_KHR_swapchain")
+@@ -2321,7 +2335,7 @@ class VkPresentInfoKHR {
+ const VkSemaphore* pWaitSemaphores
+ u32 swapchainCount
+ const VkSwapchainKHR* pSwapchains
+- const u32* imageIndices
++ const u32* pImageIndices
+ VkResult* pResults
+ }
+
+@@ -2378,13 +2392,14 @@ class VkDisplayPlaneCapabilitiesKHR {
+ class VkDisplaySurfaceCreateInfoKHR {
+ VkStructureType sType
+ const void* pNext
++ VkDisplaySurfaceCreateFlagsKHR flags
+ VkDisplayModeKHR displayMode
+ u32 planeIndex
+ u32 planeStackIndex
+- VkSurfaceTransformKHR transform
++ VkSurfaceTransformFlagBitsKHR transform
+ f32 globalAlpha
+- VkDisplayPlaneAlphaFlagsKHR alphaMode
+- VkExtent2D imageSize
++ VkDisplayPlaneAlphaFlagBitsKHR alphaMode
++ VkExtent2D imageExtent
+ }
+
+ @extension("VK_KHR_display_swapchain")
+@@ -2767,7 +2782,7 @@ cmd VkResult vkAllocateMemory(
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory) {
+- assert(pAllocateInfo.sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO)
++ assert(pAllocateInfo.sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO)
+ deviceObject := GetDevice(device)
+
+ memory := ?
+@@ -3830,7 +3845,7 @@ cmd VkResult vkAllocateCommandBuffers(
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers) {
+- assert(pAllocateInfo[0].sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO)
++ assert(pAllocateInfo[0].sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO)
+
+ count := pAllocateInfo[0].bufferCount
+ commandBuffers := pCommandBuffers[0:count]
+@@ -4545,7 +4560,7 @@ cmd void vkCmdPushConstants(
+ VkShaderStageFlags stageFlags,
+ u32 offset,
+ u32 size,
+- const void* values) {
++ const void* pValues) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ layoutObject := GetPipelineLayout(layout)
+ assert(commandBufferObject.device == layoutObject.device)
+@@ -4738,7 +4753,7 @@ cmd VkResult vkAcquireNextImageKHR(
+ @extension("VK_KHR_swapchain")
+ cmd VkResult vkQueuePresentKHR(
+ VkQueue queue,
+- VkPresentInfoKHR* pPresentInfo) {
++ const VkPresentInfoKHR* pPresentInfo) {
+ queueObject := GetQueue(queue)
+
+ presentInfo := ?
+@@ -4768,8 +4783,8 @@ cmd VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ @extension("VK_KHR_display")
+ cmd VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
+ VkPhysicalDevice physicalDevice,
+- u32* pPropertyCount,
+- VkDisplayKHR* pProperties) {
++ u32* pDisplayCount,
++ VkDisplayKHR* pDisplays) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+ return ?
+ }
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index ba749a1..a255e1f 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,11 +41,11 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 206, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 209, 0)
+
+
+ #define VK_NULL_HANDLE 0
+-
++
+
+
+ #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
+@@ -56,7 +56,7 @@ extern "C" {
+ #else
+ #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
+ #endif
+-
++
+
+
+ typedef uint32_t VkFlags;
+@@ -129,8 +129,7 @@ typedef enum VkResult {
+ VK_SUBOPTIMAL_KHR = 0x40000403,
+ VK_ERROR_OUT_OF_DATE_KHR = 0xC0000804,
+ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC0001002,
+- VK_ERROR_INVALID_ANDROID_WINDOW_KHR = 0xC0002400,
+- VK_ERROR_ANDROID_WINDOW_IN_USE_KHR = 0xC0002401,
++ VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = 0xC0002400,
+ VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED,
+ VK_RESULT_END_RANGE = VK_INCOMPLETE,
+ VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + 1),
+@@ -143,7 +142,7 @@ typedef enum VkStructureType {
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
+ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
+ VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
+- VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 5,
++ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
+ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
+ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
+ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
+@@ -172,20 +171,20 @@ typedef enum VkStructureType {
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
+ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
+- VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 34,
++ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
+ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
+ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
+ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
+ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
+ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
+- VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 40,
++ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 41,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 42,
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43,
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44,
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45,
+- VK_STRUCTURE_TYPE_LAYER_INSTANCE_CREATE_INFO = 46,
+- VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 47,
++ VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 46,
++ VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 47,
+ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 0xC0000800,
+ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 0xC0000801,
+ VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 0xC0000C00,
+@@ -193,8 +192,8 @@ typedef enum VkStructureType {
+ VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR = 0xC0001000,
+ VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 0xC0001001,
+ VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+- VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO,
+- VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
++ VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
++ VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+ VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+ } VkStructureType;
+
+@@ -220,14 +219,14 @@ typedef enum VkInternalAllocationType {
+
+ typedef enum VkFormat {
+ VK_FORMAT_UNDEFINED = 0,
+- VK_FORMAT_R4G4_UNORM = 1,
+- VK_FORMAT_R4G4_USCALED = 2,
+- VK_FORMAT_R4G4B4A4_UNORM = 3,
+- VK_FORMAT_R4G4B4A4_USCALED = 4,
+- VK_FORMAT_R5G6B5_UNORM = 5,
+- VK_FORMAT_R5G6B5_USCALED = 6,
+- VK_FORMAT_R5G5B5A1_UNORM = 7,
+- VK_FORMAT_R5G5B5A1_USCALED = 8,
++ VK_FORMAT_R4G4_UNORM_PACK8 = 1,
++ VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
++ VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
++ VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
++ VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
++ VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
++ VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
++ VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
+ VK_FORMAT_R8_UNORM = 9,
+ VK_FORMAT_R8_SNORM = 10,
+ VK_FORMAT_R8_USCALED = 11,
+@@ -249,153 +248,164 @@ typedef enum VkFormat {
+ VK_FORMAT_R8G8B8_UINT = 27,
+ VK_FORMAT_R8G8B8_SINT = 28,
+ VK_FORMAT_R8G8B8_SRGB = 29,
+- VK_FORMAT_R8G8B8A8_UNORM = 30,
+- VK_FORMAT_R8G8B8A8_SNORM = 31,
+- VK_FORMAT_R8G8B8A8_USCALED = 32,
+- VK_FORMAT_R8G8B8A8_SSCALED = 33,
+- VK_FORMAT_R8G8B8A8_UINT = 34,
+- VK_FORMAT_R8G8B8A8_SINT = 35,
+- VK_FORMAT_R8G8B8A8_SRGB = 36,
+- VK_FORMAT_R10G10B10A2_UNORM = 37,
+- VK_FORMAT_R10G10B10A2_SNORM = 38,
+- VK_FORMAT_R10G10B10A2_USCALED = 39,
+- VK_FORMAT_R10G10B10A2_SSCALED = 40,
+- VK_FORMAT_R10G10B10A2_UINT = 41,
+- VK_FORMAT_R10G10B10A2_SINT = 42,
+- VK_FORMAT_R16_UNORM = 43,
+- VK_FORMAT_R16_SNORM = 44,
+- VK_FORMAT_R16_USCALED = 45,
+- VK_FORMAT_R16_SSCALED = 46,
+- VK_FORMAT_R16_UINT = 47,
+- VK_FORMAT_R16_SINT = 48,
+- VK_FORMAT_R16_SFLOAT = 49,
+- VK_FORMAT_R16G16_UNORM = 50,
+- VK_FORMAT_R16G16_SNORM = 51,
+- VK_FORMAT_R16G16_USCALED = 52,
+- VK_FORMAT_R16G16_SSCALED = 53,
+- VK_FORMAT_R16G16_UINT = 54,
+- VK_FORMAT_R16G16_SINT = 55,
+- VK_FORMAT_R16G16_SFLOAT = 56,
+- VK_FORMAT_R16G16B16_UNORM = 57,
+- VK_FORMAT_R16G16B16_SNORM = 58,
+- VK_FORMAT_R16G16B16_USCALED = 59,
+- VK_FORMAT_R16G16B16_SSCALED = 60,
+- VK_FORMAT_R16G16B16_UINT = 61,
+- VK_FORMAT_R16G16B16_SINT = 62,
+- VK_FORMAT_R16G16B16_SFLOAT = 63,
+- VK_FORMAT_R16G16B16A16_UNORM = 64,
+- VK_FORMAT_R16G16B16A16_SNORM = 65,
+- VK_FORMAT_R16G16B16A16_USCALED = 66,
+- VK_FORMAT_R16G16B16A16_SSCALED = 67,
+- VK_FORMAT_R16G16B16A16_UINT = 68,
+- VK_FORMAT_R16G16B16A16_SINT = 69,
+- VK_FORMAT_R16G16B16A16_SFLOAT = 70,
+- VK_FORMAT_R32_UINT = 71,
+- VK_FORMAT_R32_SINT = 72,
+- VK_FORMAT_R32_SFLOAT = 73,
+- VK_FORMAT_R32G32_UINT = 74,
+- VK_FORMAT_R32G32_SINT = 75,
+- VK_FORMAT_R32G32_SFLOAT = 76,
+- VK_FORMAT_R32G32B32_UINT = 77,
+- VK_FORMAT_R32G32B32_SINT = 78,
+- VK_FORMAT_R32G32B32_SFLOAT = 79,
+- VK_FORMAT_R32G32B32A32_UINT = 80,
+- VK_FORMAT_R32G32B32A32_SINT = 81,
+- VK_FORMAT_R32G32B32A32_SFLOAT = 82,
+- VK_FORMAT_R64_SFLOAT = 83,
+- VK_FORMAT_R64G64_SFLOAT = 84,
+- VK_FORMAT_R64G64B64_SFLOAT = 85,
+- VK_FORMAT_R64G64B64A64_SFLOAT = 86,
+- VK_FORMAT_R11G11B10_UFLOAT = 87,
+- VK_FORMAT_R9G9B9E5_UFLOAT = 88,
+- VK_FORMAT_D16_UNORM = 89,
+- VK_FORMAT_D24_UNORM_X8 = 90,
+- VK_FORMAT_D32_SFLOAT = 91,
+- VK_FORMAT_S8_UINT = 92,
+- VK_FORMAT_D16_UNORM_S8_UINT = 93,
+- VK_FORMAT_D24_UNORM_S8_UINT = 94,
+- VK_FORMAT_D32_SFLOAT_S8_UINT = 95,
+- VK_FORMAT_BC1_RGB_UNORM = 96,
+- VK_FORMAT_BC1_RGB_SRGB = 97,
+- VK_FORMAT_BC1_RGBA_UNORM = 98,
+- VK_FORMAT_BC1_RGBA_SRGB = 99,
+- VK_FORMAT_BC2_UNORM = 100,
+- VK_FORMAT_BC2_SRGB = 101,
+- VK_FORMAT_BC3_UNORM = 102,
+- VK_FORMAT_BC3_SRGB = 103,
+- VK_FORMAT_BC4_UNORM = 104,
+- VK_FORMAT_BC4_SNORM = 105,
+- VK_FORMAT_BC5_UNORM = 106,
+- VK_FORMAT_BC5_SNORM = 107,
+- VK_FORMAT_BC6H_UFLOAT = 108,
+- VK_FORMAT_BC6H_SFLOAT = 109,
+- VK_FORMAT_BC7_UNORM = 110,
+- VK_FORMAT_BC7_SRGB = 111,
+- VK_FORMAT_ETC2_R8G8B8_UNORM = 112,
+- VK_FORMAT_ETC2_R8G8B8_SRGB = 113,
+- VK_FORMAT_ETC2_R8G8B8A1_UNORM = 114,
+- VK_FORMAT_ETC2_R8G8B8A1_SRGB = 115,
+- VK_FORMAT_ETC2_R8G8B8A8_UNORM = 116,
+- VK_FORMAT_ETC2_R8G8B8A8_SRGB = 117,
+- VK_FORMAT_EAC_R11_UNORM = 118,
+- VK_FORMAT_EAC_R11_SNORM = 119,
+- VK_FORMAT_EAC_R11G11_UNORM = 120,
+- VK_FORMAT_EAC_R11G11_SNORM = 121,
+- VK_FORMAT_ASTC_4x4_UNORM = 122,
+- VK_FORMAT_ASTC_4x4_SRGB = 123,
+- VK_FORMAT_ASTC_5x4_UNORM = 124,
+- VK_FORMAT_ASTC_5x4_SRGB = 125,
+- VK_FORMAT_ASTC_5x5_UNORM = 126,
+- VK_FORMAT_ASTC_5x5_SRGB = 127,
+- VK_FORMAT_ASTC_6x5_UNORM = 128,
+- VK_FORMAT_ASTC_6x5_SRGB = 129,
+- VK_FORMAT_ASTC_6x6_UNORM = 130,
+- VK_FORMAT_ASTC_6x6_SRGB = 131,
+- VK_FORMAT_ASTC_8x5_UNORM = 132,
+- VK_FORMAT_ASTC_8x5_SRGB = 133,
+- VK_FORMAT_ASTC_8x6_UNORM = 134,
+- VK_FORMAT_ASTC_8x6_SRGB = 135,
+- VK_FORMAT_ASTC_8x8_UNORM = 136,
+- VK_FORMAT_ASTC_8x8_SRGB = 137,
+- VK_FORMAT_ASTC_10x5_UNORM = 138,
+- VK_FORMAT_ASTC_10x5_SRGB = 139,
+- VK_FORMAT_ASTC_10x6_UNORM = 140,
+- VK_FORMAT_ASTC_10x6_SRGB = 141,
+- VK_FORMAT_ASTC_10x8_UNORM = 142,
+- VK_FORMAT_ASTC_10x8_SRGB = 143,
+- VK_FORMAT_ASTC_10x10_UNORM = 144,
+- VK_FORMAT_ASTC_10x10_SRGB = 145,
+- VK_FORMAT_ASTC_12x10_UNORM = 146,
+- VK_FORMAT_ASTC_12x10_SRGB = 147,
+- VK_FORMAT_ASTC_12x12_UNORM = 148,
+- VK_FORMAT_ASTC_12x12_SRGB = 149,
+- VK_FORMAT_B4G4R4A4_UNORM = 150,
+- VK_FORMAT_B5G5R5A1_UNORM = 151,
+- VK_FORMAT_B5G6R5_UNORM = 152,
+- VK_FORMAT_B5G6R5_USCALED = 153,
+- VK_FORMAT_B8G8R8_UNORM = 154,
+- VK_FORMAT_B8G8R8_SNORM = 155,
+- VK_FORMAT_B8G8R8_USCALED = 156,
+- VK_FORMAT_B8G8R8_SSCALED = 157,
+- VK_FORMAT_B8G8R8_UINT = 158,
+- VK_FORMAT_B8G8R8_SINT = 159,
+- VK_FORMAT_B8G8R8_SRGB = 160,
+- VK_FORMAT_B8G8R8A8_UNORM = 161,
+- VK_FORMAT_B8G8R8A8_SNORM = 162,
+- VK_FORMAT_B8G8R8A8_USCALED = 163,
+- VK_FORMAT_B8G8R8A8_SSCALED = 164,
+- VK_FORMAT_B8G8R8A8_UINT = 165,
+- VK_FORMAT_B8G8R8A8_SINT = 166,
+- VK_FORMAT_B8G8R8A8_SRGB = 167,
+- VK_FORMAT_B10G10R10A2_UNORM = 168,
+- VK_FORMAT_B10G10R10A2_SNORM = 169,
+- VK_FORMAT_B10G10R10A2_USCALED = 170,
+- VK_FORMAT_B10G10R10A2_SSCALED = 171,
+- VK_FORMAT_B10G10R10A2_UINT = 172,
+- VK_FORMAT_B10G10R10A2_SINT = 173,
++ VK_FORMAT_B8G8R8_UNORM = 30,
++ VK_FORMAT_B8G8R8_SNORM = 31,
++ VK_FORMAT_B8G8R8_USCALED = 32,
++ VK_FORMAT_B8G8R8_SSCALED = 33,
++ VK_FORMAT_B8G8R8_UINT = 34,
++ VK_FORMAT_B8G8R8_SINT = 35,
++ VK_FORMAT_B8G8R8_SRGB = 36,
++ VK_FORMAT_R8G8B8A8_UNORM = 37,
++ VK_FORMAT_R8G8B8A8_SNORM = 38,
++ VK_FORMAT_R8G8B8A8_USCALED = 39,
++ VK_FORMAT_R8G8B8A8_SSCALED = 40,
++ VK_FORMAT_R8G8B8A8_UINT = 41,
++ VK_FORMAT_R8G8B8A8_SINT = 42,
++ VK_FORMAT_R8G8B8A8_SRGB = 43,
++ VK_FORMAT_B8G8R8A8_UNORM = 44,
++ VK_FORMAT_B8G8R8A8_SNORM = 45,
++ VK_FORMAT_B8G8R8A8_USCALED = 46,
++ VK_FORMAT_B8G8R8A8_SSCALED = 47,
++ VK_FORMAT_B8G8R8A8_UINT = 48,
++ VK_FORMAT_B8G8R8A8_SINT = 49,
++ VK_FORMAT_B8G8R8A8_SRGB = 50,
++ VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
++ VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
++ VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
++ VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
++ VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
++ VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
++ VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
++ VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
++ VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
++ VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
++ VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
++ VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
++ VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
++ VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
++ VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
++ VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
++ VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
++ VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
++ VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
++ VK_FORMAT_R16_UNORM = 70,
++ VK_FORMAT_R16_SNORM = 71,
++ VK_FORMAT_R16_USCALED = 72,
++ VK_FORMAT_R16_SSCALED = 73,
++ VK_FORMAT_R16_UINT = 74,
++ VK_FORMAT_R16_SINT = 75,
++ VK_FORMAT_R16_SFLOAT = 76,
++ VK_FORMAT_R16G16_UNORM = 77,
++ VK_FORMAT_R16G16_SNORM = 78,
++ VK_FORMAT_R16G16_USCALED = 79,
++ VK_FORMAT_R16G16_SSCALED = 80,
++ VK_FORMAT_R16G16_UINT = 81,
++ VK_FORMAT_R16G16_SINT = 82,
++ VK_FORMAT_R16G16_SFLOAT = 83,
++ VK_FORMAT_R16G16B16_UNORM = 84,
++ VK_FORMAT_R16G16B16_SNORM = 85,
++ VK_FORMAT_R16G16B16_USCALED = 86,
++ VK_FORMAT_R16G16B16_SSCALED = 87,
++ VK_FORMAT_R16G16B16_UINT = 88,
++ VK_FORMAT_R16G16B16_SINT = 89,
++ VK_FORMAT_R16G16B16_SFLOAT = 90,
++ VK_FORMAT_R16G16B16A16_UNORM = 91,
++ VK_FORMAT_R16G16B16A16_SNORM = 92,
++ VK_FORMAT_R16G16B16A16_USCALED = 93,
++ VK_FORMAT_R16G16B16A16_SSCALED = 94,
++ VK_FORMAT_R16G16B16A16_UINT = 95,
++ VK_FORMAT_R16G16B16A16_SINT = 96,
++ VK_FORMAT_R16G16B16A16_SFLOAT = 97,
++ VK_FORMAT_R32_UINT = 98,
++ VK_FORMAT_R32_SINT = 99,
++ VK_FORMAT_R32_SFLOAT = 100,
++ VK_FORMAT_R32G32_UINT = 101,
++ VK_FORMAT_R32G32_SINT = 102,
++ VK_FORMAT_R32G32_SFLOAT = 103,
++ VK_FORMAT_R32G32B32_UINT = 104,
++ VK_FORMAT_R32G32B32_SINT = 105,
++ VK_FORMAT_R32G32B32_SFLOAT = 106,
++ VK_FORMAT_R32G32B32A32_UINT = 107,
++ VK_FORMAT_R32G32B32A32_SINT = 108,
++ VK_FORMAT_R32G32B32A32_SFLOAT = 109,
++ VK_FORMAT_R64_UINT = 110,
++ VK_FORMAT_R64_SINT = 111,
++ VK_FORMAT_R64_SFLOAT = 112,
++ VK_FORMAT_R64G64_UINT = 113,
++ VK_FORMAT_R64G64_SINT = 114,
++ VK_FORMAT_R64G64_SFLOAT = 115,
++ VK_FORMAT_R64G64B64_UINT = 116,
++ VK_FORMAT_R64G64B64_SINT = 117,
++ VK_FORMAT_R64G64B64_SFLOAT = 118,
++ VK_FORMAT_R64G64B64A64_UINT = 119,
++ VK_FORMAT_R64G64B64A64_SINT = 120,
++ VK_FORMAT_R64G64B64A64_SFLOAT = 121,
++ VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
++ VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
++ VK_FORMAT_D16_UNORM = 124,
++ VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
++ VK_FORMAT_D32_SFLOAT = 126,
++ VK_FORMAT_S8_UINT = 127,
++ VK_FORMAT_D16_UNORM_S8_UINT = 128,
++ VK_FORMAT_D24_UNORM_S8_UINT = 129,
++ VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
++ VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
++ VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
++ VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
++ VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
++ VK_FORMAT_BC2_UNORM_BLOCK = 135,
++ VK_FORMAT_BC2_SRGB_BLOCK = 136,
++ VK_FORMAT_BC3_UNORM_BLOCK = 137,
++ VK_FORMAT_BC3_SRGB_BLOCK = 138,
++ VK_FORMAT_BC4_UNORM_BLOCK = 139,
++ VK_FORMAT_BC4_SNORM_BLOCK = 140,
++ VK_FORMAT_BC5_UNORM_BLOCK = 141,
++ VK_FORMAT_BC5_SNORM_BLOCK = 142,
++ VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
++ VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
++ VK_FORMAT_BC7_UNORM_BLOCK = 145,
++ VK_FORMAT_BC7_SRGB_BLOCK = 146,
++ VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
++ VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
++ VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
++ VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
++ VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
++ VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
++ VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
++ VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
++ VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
++ VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
++ VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
++ VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
++ VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
++ VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
++ VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
++ VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
++ VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
++ VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
++ VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
++ VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
++ VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
++ VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
++ VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
++ VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
++ VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
++ VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
++ VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
++ VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
++ VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
++ VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
++ VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
++ VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
++ VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
++ VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
++ VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
++ VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
++ VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
++ VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
+ VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
+- VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT,
+- VK_FORMAT_RANGE_SIZE = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1),
++ VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
++ VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
+ VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
+ } VkFormat;
+
+@@ -1041,6 +1051,11 @@ typedef enum VkCommandBufferUsageFlagBits {
+ } VkCommandBufferUsageFlagBits;
+ typedef VkFlags VkCommandBufferUsageFlags;
+
++typedef enum VkQueryControlFlagBits {
++ VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
++} VkQueryControlFlagBits;
++typedef VkFlags VkQueryControlFlags;
++
+ typedef enum VkCommandBufferResetFlagBits {
+ VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+ } VkCommandBufferResetFlagBits;
+@@ -1054,11 +1069,6 @@ typedef enum VkStencilFaceFlagBits {
+ } VkStencilFaceFlagBits;
+ typedef VkFlags VkStencilFaceFlags;
+
+-typedef enum VkQueryControlFlagBits {
+- VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
+-} VkQueryControlFlagBits;
+-typedef VkFlags VkQueryControlFlags;
+-
+ typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
+ void* pUserData,
+ size_t size,
+@@ -1106,9 +1116,9 @@ typedef struct VkInstanceCreateInfo {
+ VkInstanceCreateFlags flags;
+ const VkApplicationInfo* pApplicationInfo;
+ uint32_t enabledLayerNameCount;
+- const char*const* ppEnabledLayerNames;
++ const char* const* ppEnabledLayerNames;
+ uint32_t enabledExtensionNameCount;
+- const char*const* ppEnabledExtensionNames;
++ const char* const* ppEnabledExtensionNames;
+ } VkInstanceCreateInfo;
+
+ typedef struct VkAllocationCallbacks {
+@@ -1364,9 +1374,9 @@ typedef struct VkDeviceCreateInfo {
+ uint32_t queueCreateInfoCount;
+ const VkDeviceQueueCreateInfo* pQueueCreateInfos;
+ uint32_t enabledLayerNameCount;
+- const char*const* ppEnabledLayerNames;
++ const char* const* ppEnabledLayerNames;
+ uint32_t enabledExtensionNameCount;
+- const char*const* ppEnabledExtensionNames;
++ const char* const* ppEnabledExtensionNames;
+ const VkPhysicalDeviceFeatures* pEnabledFeatures;
+ } VkDeviceCreateInfo;
+
+@@ -2012,6 +2022,9 @@ typedef struct VkCommandBufferBeginInfo {
+ VkRenderPass renderPass;
+ uint32_t subpass;
+ VkFramebuffer framebuffer;
++ VkBool32 occlusionQueryEnable;
++ VkQueryControlFlags queryFlags;
++ VkQueryPipelineStatisticFlags pipelineStatistics;
+ } VkCommandBufferBeginInfo;
+
+ typedef struct VkBufferCopy {
+@@ -2285,7 +2298,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQue
+ typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+ typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry);
+ typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+-typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values);
++typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
+ typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
+ typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
+ typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
+@@ -3060,7 +3073,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+- const void* values);
++ const void* pValues);
+
+ VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
+ VkCommandBuffer commandBuffer,
+@@ -3083,27 +3096,11 @@ VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
+ #define VK_KHR_surface 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
+
+-#define VK_KHR_SURFACE_REVISION 23
++#define VK_KHR_SURFACE_REVISION 24
+ #define VK_KHR_SURFACE_EXTENSION_NUMBER 1
+ #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"
+
+
+-typedef enum VkSurfaceTransformKHR {
+- VK_SURFACE_TRANSFORM_NONE_KHR = 0,
+- VK_SURFACE_TRANSFORM_ROT90_KHR = 1,
+- VK_SURFACE_TRANSFORM_ROT180_KHR = 2,
+- VK_SURFACE_TRANSFORM_ROT270_KHR = 3,
+- VK_SURFACE_TRANSFORM_HMIRROR_KHR = 4,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT90_KHR = 5,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT180_KHR = 6,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT270_KHR = 7,
+- VK_SURFACE_TRANSFORM_INHERIT_KHR = 8,
+- VK_SURFACE_TRANSFORM_BEGIN_RANGE = VK_SURFACE_TRANSFORM_NONE_KHR,
+- VK_SURFACE_TRANSFORM_END_RANGE = VK_SURFACE_TRANSFORM_INHERIT_KHR,
+- VK_SURFACE_TRANSFORM_RANGE_SIZE = (VK_SURFACE_TRANSFORM_INHERIT_KHR - VK_SURFACE_TRANSFORM_NONE_KHR + 1),
+- VK_SURFACE_TRANSFORM_MAX_ENUM = 0x7FFFFFFF
+-} VkSurfaceTransformKHR;
+-
+ typedef enum VkColorSpaceKHR {
+ VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0,
+ VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
+@@ -3151,10 +3148,10 @@ typedef struct VkSurfaceCapabilitiesKHR {
+ VkExtent2D currentExtent;
+ VkExtent2D minImageExtent;
+ VkExtent2D maxImageExtent;
++ uint32_t maxImageArrayLayers;
+ VkSurfaceTransformFlagsKHR supportedTransforms;
+- VkSurfaceTransformKHR currentTransform;
++ VkSurfaceTransformFlagBitsKHR currentTransform;
+ VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
+- uint32_t maxImageArraySize;
+ VkImageUsageFlags supportedUsageFlags;
+ } VkSurfaceCapabilitiesKHR;
+
+@@ -3203,28 +3200,31 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
+ #define VK_KHR_swapchain 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
+
+-#define VK_KHR_SWAPCHAIN_REVISION 66
++#define VK_KHR_SWAPCHAIN_REVISION 67
+ #define VK_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+ #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
+
++typedef VkFlags VkSwapchainCreateFlagsKHR;
++
+ typedef struct VkSwapchainCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
++ VkSwapchainCreateFlagsKHR flags;
+ VkSurfaceKHR surface;
+ uint32_t minImageCount;
+ VkFormat imageFormat;
+ VkColorSpaceKHR imageColorSpace;
+ VkExtent2D imageExtent;
+- VkImageUsageFlags imageUsageFlags;
+- VkSurfaceTransformKHR preTransform;
+- VkCompositeAlphaFlagBitsKHR compositeAlpha;
+- uint32_t imageArraySize;
+- VkSharingMode sharingMode;
++ uint32_t imageArrayLayers;
++ VkImageUsageFlags imageUsage;
++ VkSharingMode imageSharingMode;
+ uint32_t queueFamilyIndexCount;
+ const uint32_t* pQueueFamilyIndices;
++ VkSurfaceTransformFlagBitsKHR preTransform;
++ VkCompositeAlphaFlagBitsKHR compositeAlpha;
+ VkPresentModeKHR presentMode;
+- VkSwapchainKHR oldSwapchain;
+ VkBool32 clipped;
++ VkSwapchainKHR oldSwapchain;
+ } VkSwapchainCreateInfoKHR;
+
+ typedef struct VkPresentInfoKHR {
+@@ -3234,7 +3234,7 @@ typedef struct VkPresentInfoKHR {
+ const VkSemaphore* pWaitSemaphores;
+ uint32_t swapchainCount;
+ const VkSwapchainKHR* pSwapchains;
+- const uint32_t* imageIndices;
++ const uint32_t* pImageIndices;
+ VkResult* pResults;
+ } VkPresentInfoKHR;
+
+@@ -3243,7 +3243,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const V
+ typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
+ typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
+-typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, VkPresentInfoKHR* pPresentInfo);
++typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
+
+ #ifdef VK_PROTOTYPES
+ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
+@@ -3273,24 +3273,26 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
+
+ VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
+ VkQueue queue,
+- VkPresentInfoKHR* pPresentInfo);
++ const VkPresentInfoKHR* pPresentInfo);
+ #endif
+
+ #define VK_KHR_display 1
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
+ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
+
+-#define VK_KHR_DISPLAY_REVISION 19
++#define VK_KHR_DISPLAY_REVISION 21
+ #define VK_KHR_DISPLAY_EXTENSION_NUMBER 3
+ #define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"
+
+
+ typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
+- VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000001,
+- VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000002,
+- VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000004,
++ VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
++ VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
++ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
++ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
+ } VkDisplayPlaneAlphaFlagBitsKHR;
+ typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
++typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
+
+ typedef struct VkDisplayPropertiesKHR {
+ VkDisplayKHR display;
+@@ -3338,19 +3340,20 @@ typedef struct VkDisplayPlanePropertiesKHR {
+ typedef struct VkDisplaySurfaceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
++ VkDisplaySurfaceCreateFlagsKHR flags;
+ VkDisplayModeKHR displayMode;
+ uint32_t planeIndex;
+ uint32_t planeStackIndex;
+- VkSurfaceTransformKHR transform;
++ VkSurfaceTransformFlagBitsKHR transform;
+ float globalAlpha;
+- VkDisplayPlaneAlphaFlagsKHR alphaMode;
+- VkExtent2D imageSize;
++ VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
++ VkExtent2D imageExtent;
+ } VkDisplaySurfaceCreateInfoKHR;
+
+
+ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
+-typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayKHR* pProperties);
++typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
+ typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeCreateInfoKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+@@ -3369,8 +3372,8 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+
+ VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
+ VkPhysicalDevice physicalDevice,
+- uint32_t* pPropertyCount,
+- VkDisplayKHR* pProperties);
++ uint32_t* pDisplayCount,
++ VkDisplayKHR* pDisplays);
+
+ VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+@@ -3529,7 +3532,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
+ #define VK_KHR_android_surface 1
+ #include <android/native_window.h>
+
+-#define VK_KHR_ANDROID_SURFACE_REVISION 3
++#define VK_KHR_ANDROID_SURFACE_REVISION 4
+ #define VK_KHR_ANDROID_SURFACE_EXTENSION_NUMBER 9
+ #define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
+
+diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
+index 67b8c38..9c0444f 100644
+--- a/vulkan/libvulkan/entry.cpp
++++ b/vulkan/libvulkan/entry.cpp
+@@ -702,8 +702,8 @@ VKAPI_ATTR void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQuery
+ }
+
+ __attribute__((visibility("default")))
+-VKAPI_ATTR void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) {
+- GetVtbl(commandBuffer).CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, values);
++VKAPI_ATTR void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {
++ GetVtbl(commandBuffer).CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
+ }
+
+ __attribute__((visibility("default")))
+@@ -772,7 +772,7 @@ VKAPI_ATTR VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapch
+ }
+
+ __attribute__((visibility("default")))
+-VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, VkPresentInfoKHR* pPresentInfo) {
++VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
+ return GetVtbl(queue).QueuePresentKHR(queue, pPresentInfo);
+ }
+
+diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
+index 35d0eaa..1f777fc 100644
+--- a/vulkan/libvulkan/loader.h
++++ b/vulkan/libvulkan/loader.h
+@@ -305,7 +305,7 @@ VKAPI_ATTR VkResult AcquireNextImageKHR(VkDevice device,
+ VkSemaphore semaphore,
+ uint32_t* image_index);
+ VKAPI_ATTR VkResult
+-QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info);
++QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info);
+
+ } // namespace vulkan
+
+diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
+index ff02b35..39a581c 100644
+--- a/vulkan/libvulkan/swapchain.cpp
++++ b/vulkan/libvulkan/swapchain.cpp
+@@ -230,9 +230,9 @@ VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ capabilities->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_KHR;
+
+ // TODO(jessehall): Implement based on NATIVE_WINDOW_TRANSFORM_HINT.
+- capabilities->currentTransform = VK_SURFACE_TRANSFORM_NONE_KHR;
++ capabilities->currentTransform = VK_SURFACE_TRANSFORM_NONE_BIT_KHR;
+
+- capabilities->maxImageArraySize = 1;
++ capabilities->maxImageArrayLayers = 1;
+
+ // TODO(jessehall): I think these are right, but haven't thought hard about
+ // it. Do we need to query the driver for support of any of these?
+@@ -314,7 +314,7 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ "color spaces other than SRGB_NONLINEAR not yet implemented");
+ ALOGE_IF(create_info->oldSwapchain,
+ "swapchain re-creation not yet implemented");
+- ALOGE_IF(create_info->preTransform != VK_SURFACE_TRANSFORM_NONE_KHR,
++ ALOGE_IF(create_info->preTransform != VK_SURFACE_TRANSFORM_NONE_BIT_KHR,
+ "swapchain preTransform not yet implemented");
+ ALOGE_IF(create_info->presentMode != VK_PRESENT_MODE_FIFO_KHR,
+ "present modes other than FIFO are not yet implemented");
+@@ -371,7 +371,7 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ // TODO(jessehall): Remove conditional once all drivers have been updated
+ if (driver_vtbl.GetSwapchainGrallocUsageANDROID) {
+ result = driver_vtbl.GetSwapchainGrallocUsageANDROID(
+- device, create_info->imageFormat, create_info->imageUsageFlags,
++ device, create_info->imageFormat, create_info->imageUsage,
+ &gralloc_usage);
+ if (result != VK_SUCCESS) {
+ ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
+@@ -418,9 +418,9 @@ VkResult CreateSwapchainKHR(VkDevice device,
+ .arrayLayers = 1,
+ .samples = VK_SAMPLE_COUNT_1_BIT,
+ .tiling = VK_IMAGE_TILING_OPTIMAL,
+- .usage = create_info->imageUsageFlags,
++ .usage = create_info->imageUsage,
+ .flags = 0,
+- .sharingMode = create_info->sharingMode,
++ .sharingMode = create_info->imageSharingMode,
+ .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
+ .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
+ };
+@@ -612,7 +612,7 @@ VkResult AcquireNextImageKHR(VkDevice device,
+ }
+
+ VKAPI_ATTR
+-VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info) {
++VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) {
+ ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+ "vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",
+ present_info->sType);
+@@ -624,7 +624,7 @@ VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info) {
+ Swapchain& swapchain =
+ *SwapchainFromHandle(present_info->pSwapchains[sc]);
+ ANativeWindow* window = swapchain.surface.window.get();
+- uint32_t image_idx = present_info->imageIndices[sc];
++ uint32_t image_idx = present_info->pImageIndices[sc];
+ Swapchain::Image& img = swapchain.images[image_idx];
+ VkResult result;
+ int err;
+--
+2.4.0
+
--- /dev/null
+From 9b545cb7b82a038b6da6355b742da425cbfd05fb Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 30 Nov 2015 16:22:16 -0800
+Subject: [PATCH 28/30] vulkan: Update from version 0.209.0 to 0.210.0
+
+Change-Id: Ic5791cf1193de1e5d2ce355d9dcc4450b0def85a
+---
+ vulkan/api/vulkan.api | 53 +++++++++++++++++++--------------
+ vulkan/include/vulkan/vulkan.h | 45 +++++++++++++++-------------
+ vulkan/libvulkan/get_proc_addr.cpp.tmpl | 15 +++++++++-
+ 3 files changed, 70 insertions(+), 43 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index d35e11d..243951d 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -27,7 +27,7 @@ import platform "platform.api"
+
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+-define VERSION_MINOR 209
++define VERSION_MINOR 210
+ define VERSION_PATCH 0
+
+ // API limits
+@@ -57,7 +57,7 @@ define NULL_HANDLE 0
+ @extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NUMBER 3
+ @extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"
+
+-@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_REVISION 8
++@extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_REVISION 9
+ @extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4
+ @extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
+
+@@ -630,8 +630,7 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 0xc0000c01,
+
+ //@extension("VK_KHR_display_swapchain")
+- VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR = 0xc0001000,
+- VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR = 0xc0001001,
++ VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR = 0xc0001000,
+ }
+
+ enum VkSubpassContents {
+@@ -673,7 +672,7 @@ enum VkResult {
+ VK_ERROR_OUT_OF_DATE_KHR = 0xC0000804,
+
+ //@extension("VK_KHR_display_swapchain")
+- VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC0001002,
++ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC0001001,
+
+ //@extension("VK_KHR_android_surface")
+ VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = 0xC0002400,
+@@ -1147,15 +1146,15 @@ bitfield VkCullModeFlagBits {
+ type VkFlags VkSurfaceTransformFlagsKHR
+ @extension("VK_KHR_swapchain")
+ bitfield VkSurfaceTransformFlagBitsKHR {
+- VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
+- VK_SURFACE_TRANSFORM_ROT90_BIT_KHR = 0x00000002,
+- VK_SURFACE_TRANSFORM_ROT180_BIT_KHR = 0x00000004,
+- VK_SURFACE_TRANSFORM_ROT270_BIT_KHR = 0x00000008,
+- VK_SURFACE_TRANSFORM_HMIRROR_BIT_KHR = 0x00000010,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT90_BIT_KHR = 0x00000020,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT180_BIT_KHR = 0x00000040,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT270_BIT_KHR = 0x00000080,
+- VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
++ VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
++ VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
++ VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
++ VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
++ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
++ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
++ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
++ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
++ VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
+ }
+
+ @extension("VK_KHR_swapchain")
+@@ -1190,6 +1189,12 @@ type VkFlags VkDisplaySurfaceCreateFlagsKHR
+ //bitfield VkDisplaySurfaceCreateFlagBitsKHR {
+ //}
+
++@extension("VK_KHR_display")
++type VkFlags VkDisplayModeCreateFlagsKHR
++//@extension("VK_KHR_display")
++//bitfield VkDisplayModeCreateFlagBitsKHR {
++//}
++
+
+ //////////////////
+ // Structures //
+@@ -2366,6 +2371,7 @@ class VkDisplayModePropertiesKHR {
+ class VkDisplayModeCreateInfoKHR {
+ VkStructureType sType
+ const void* pNext
++ VkDisplayModeCreateFlagsKHR flags
+ VkDisplayModeParametersKHR parameters
+ }
+
+@@ -2403,13 +2409,6 @@ class VkDisplaySurfaceCreateInfoKHR {
+ }
+
+ @extension("VK_KHR_display_swapchain")
+-class VkDisplaySwapchainCreateInfoKHR {
+- VkStructureType sType
+- const void* pNext
+- const VkSwapchainCreateInfoKHR* pNextSwapchainCreateInfo
+-}
+-
+-@extension("VK_KHR_display_swapchain")
+ class VkDisplayPresentInfoKHR {
+ VkStructureType sType
+ const void* pNext
+@@ -4813,7 +4812,7 @@ cmd VkResult vkCreateDisplayModeKHR(
+ @extension("VK_KHR_display")
+ cmd VkResult vkGetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+- VkDisplayModeCreateInfoKHR mode,
++ VkDisplayModeKHR mode,
+ u32 planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
+ physicalDeviceObject := GetPhysicalDevice(physicalDevice)
+@@ -4829,6 +4828,16 @@ cmd VkResult vkCreateDisplayPlaneSurfaceKHR(
+ return ?
+ }
+
++@extension("VK_KHR_display_swapchain")
++cmd VkResult vkCreateSharedSwapchainsKHR(
++ VkDevice device,
++ u32 swapchainCount,
++ const VkSwapchainCreateInfoKHR* pCreateInfos,
++ const VkAllocationCallbacks* pAllocator,
++ VkSwapchainKHR* pSwapchains) {
++ return ?
++}
++
+ @extension("VK_KHR_xlib_surface")
+ cmd VkResult vkCreateXlibSurfaceKHR(
+ VkInstance instance,
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index a255e1f..598d98e 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 209, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 210, 0)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -128,7 +128,7 @@ typedef enum VkResult {
+ VK_ERROR_SURFACE_LOST_KHR = 0xC0000400,
+ VK_SUBOPTIMAL_KHR = 0x40000403,
+ VK_ERROR_OUT_OF_DATE_KHR = 0xC0000804,
+- VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC0001002,
++ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC0001001,
+ VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = 0xC0002400,
+ VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED,
+ VK_RESULT_END_RANGE = VK_INCOMPLETE,
+@@ -189,8 +189,7 @@ typedef enum VkStructureType {
+ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 0xC0000801,
+ VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 0xC0000C00,
+ VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 0xC0000C01,
+- VK_STRUCTURE_TYPE_DISPLAY_SWAPCHAIN_CREATE_INFO_KHR = 0xC0001000,
+- VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 0xC0001001,
++ VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 0xC0001000,
+ VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+ VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
+ VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+@@ -3123,13 +3122,13 @@ typedef enum VkPresentModeKHR {
+
+ typedef enum VkSurfaceTransformFlagBitsKHR {
+ VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
+- VK_SURFACE_TRANSFORM_ROT90_BIT_KHR = 0x00000002,
+- VK_SURFACE_TRANSFORM_ROT180_BIT_KHR = 0x00000004,
+- VK_SURFACE_TRANSFORM_ROT270_BIT_KHR = 0x00000008,
+- VK_SURFACE_TRANSFORM_HMIRROR_BIT_KHR = 0x00000010,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT90_BIT_KHR = 0x00000020,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT180_BIT_KHR = 0x00000040,
+- VK_SURFACE_TRANSFORM_HMIRROR_ROT270_BIT_KHR = 0x00000080,
++ VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
++ VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
++ VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
++ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
++ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
++ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
++ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
+ VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
+ } VkSurfaceTransformFlagBitsKHR;
+ typedef VkFlags VkSurfaceTransformFlagsKHR;
+@@ -3291,6 +3290,7 @@ typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
+ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
+ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
+ } VkDisplayPlaneAlphaFlagBitsKHR;
++typedef VkFlags VkDisplayModeCreateFlagsKHR;
+ typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
+ typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
+
+@@ -3317,6 +3317,7 @@ typedef struct VkDisplayModePropertiesKHR {
+ typedef struct VkDisplayModeCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
++ VkDisplayModeCreateFlagsKHR flags;
+ VkDisplayModeParametersKHR parameters;
+ } VkDisplayModeCreateInfoKHR;
+
+@@ -3356,7 +3357,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(V
+ typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
+ typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
+ typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
+-typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeCreateInfoKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
++typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+ typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+ #ifdef VK_PROTOTYPES
+@@ -3390,7 +3391,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
+
+ VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+- VkDisplayModeCreateInfoKHR mode,
++ VkDisplayModeKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+
+@@ -3402,16 +3403,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
+ #endif
+
+ #define VK_KHR_display_swapchain 1
+-#define VK_KHR_DISPLAY_SWAPCHAIN_REVISION 8
++#define VK_KHR_DISPLAY_SWAPCHAIN_REVISION 9
+ #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4
+ #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
+
+-typedef struct VkDisplaySwapchainCreateInfoKHR {
+- VkStructureType sType;
+- const void* pNext;
+- const VkSwapchainCreateInfoKHR* pNextSwapchainCreateInfo;
+-} VkDisplaySwapchainCreateInfoKHR;
+-
+ typedef struct VkDisplayPresentInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+@@ -3421,6 +3416,16 @@ typedef struct VkDisplayPresentInfoKHR {
+ } VkDisplayPresentInfoKHR;
+
+
++typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
++
++#ifdef VK_PROTOTYPES
++VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
++ VkDevice device,
++ uint32_t swapchainCount,
++ const VkSwapchainCreateInfoKHR* pCreateInfos,
++ const VkAllocationCallbacks* pAllocator,
++ VkSwapchainKHR* pSwapchains);
++#endif
+
+ #ifdef VK_USE_PLATFORM_XLIB_KHR
+ #define VK_KHR_xlib_surface 1
+diff --git a/vulkan/libvulkan/get_proc_addr.cpp.tmpl b/vulkan/libvulkan/get_proc_addr.cpp.tmpl
+index aad177d..423dea4 100644
+--- a/vulkan/libvulkan/get_proc_addr.cpp.tmpl
++++ b/vulkan/libvulkan/get_proc_addr.cpp.tmpl
+@@ -217,8 +217,21 @@ bool LoadDeviceVtbl(VkDevice device,
+ success = false;
+ }
+ {{range $f := AllCommands $}}
++ {{if and (eq (Macro "Vtbl" $f) "Device") (not (eq (Macro "FunctionName" $f) "vkGetDeviceProcAddr"))}}
++ {{if not (GetAnnotation $f "extension")}}
++ vtbl.{{TrimPrefix "vk" (Macro "FunctionName" $f)}} = §
++ reinterpret_cast<{{Macro "FunctionPtrName" $f}}>(§
++ get_proc_addr(device, "{{Macro "FunctionName" $f}}"));
++ if (UNLIKELY(!vtbl.{{TrimPrefix "vk" (Macro "FunctionName" $f)}})) {
++ ALOGE("missing device proc: %s", "{{Macro "FunctionName" $f}}");
++ success = false;
++ }
++ {{end}}
++ {{end}}
++ {{end}}
++ {{range $f := AllCommands $}}
+ {{if eq (Macro "Vtbl" $f) "Device"}}
+- {{if not (eq (Macro "FunctionName" $f) "vkGetDeviceProcAddr")}}
++ {{if and (GetAnnotation $f "extension") (Macro "IsDispatched" $f)}}
+ vtbl.{{TrimPrefix "vk" (Macro "FunctionName" $f)}} = §
+ reinterpret_cast<{{Macro "FunctionPtrName" $f}}>(§
+ get_proc_addr(device, "{{Macro "FunctionName" $f}}"));
+--
+2.4.0
+
--- /dev/null
+From f0429ae266f2738835c80808a3ae4133165bcff5 Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 30 Nov 2015 21:12:55 -0800
+Subject: [PATCH 29/30] vulkan: Assign enums to the correct extension
+
+Change-Id: I9ba61b9bfe349f7079833de89d66aa4a2e993e2f
+---
+ vulkan/api/vulkan.api | 10 +++++-----
+ 1 file changed, 5 insertions(+), 5 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 243951d..63188d5 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -690,7 +690,7 @@ enum VkDynamicState {
+ VK_DYNAMIC_STATE_STENCIL_REFERENCE = 0x00000008,
+ }
+
+-@extension("VK_KHR_swapchain")
++@extension("VK_KHR_surface")
+ enum VkPresentModeKHR {
+ VK_PRESENT_MODE_IMMEDIATE_KHR = 0x00000000,
+ VK_PRESENT_MODE_MAILBOX_KHR = 0x00000001,
+@@ -698,7 +698,7 @@ enum VkPresentModeKHR {
+ VK_PRESENT_MODE_FIFO_RELAXED_KHR = 0x00000003,
+ }
+
+-@extension("VK_KHR_swapchain")
++@extension("VK_KHR_surface")
+ enum VkColorSpaceKHR {
+ VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0x00000000,
+ }
+@@ -1142,7 +1142,7 @@ bitfield VkCullModeFlagBits {
+ VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
+ }
+
+-@extension("VK_KHR_swapchain")
++@extension("VK_KHR_surface")
+ type VkFlags VkSurfaceTransformFlagsKHR
+ @extension("VK_KHR_swapchain")
+ bitfield VkSurfaceTransformFlagBitsKHR {
+@@ -1157,9 +1157,9 @@ bitfield VkSurfaceTransformFlagBitsKHR {
+ VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
+ }
+
+-@extension("VK_KHR_swapchain")
++@extension("VK_KHR_surface")
+ type VkFlags VkCompositeAlphaFlagsKHR
+-@extension("VK_KHR_swapchain")
++@extension("VK_KHR_surface")
+ bitfield VkCompositeAlphaFlagBitsKHR {
+ VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
+ VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
+--
+2.4.0
+
--- /dev/null
+From 1bed42cafc4ee646dd964d99749dabd45399667a Mon Sep 17 00:00:00 2001
+From: Jesse Hall <jessehall@google.com>
+Date: Mon, 30 Nov 2015 21:44:14 -0800
+Subject: [PATCH 30/30] vulkan: Update from version 0.210.0 to 0.210.1
+
+Change-Id: I9adf217587a8b666bcf04818004dce4e97b87fd1
+---
+ vulkan/api/vulkan.api | 59 +++++++++++++++++++++---------------------
+ vulkan/include/vulkan/vulkan.h | 24 ++++++++---------
+ vulkan/libvulkan/Android.mk | 4 ---
+ vulkan/tools/Android.mk | 4 ---
+ 4 files changed, 42 insertions(+), 49 deletions(-)
+
+diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
+index 63188d5..b31e6a2 100644
+--- a/vulkan/api/vulkan.api
++++ b/vulkan/api/vulkan.api
+@@ -28,7 +28,7 @@ import platform "platform.api"
+ // API version (major.minor.patch)
+ define VERSION_MAJOR 0
+ define VERSION_MINOR 210
+-define VERSION_PATCH 0
++define VERSION_PATCH 1
+
+ // API limits
+ define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256
+@@ -148,7 +148,7 @@ enum VkImageLayout {
+ VK_IMAGE_LAYOUT_PREINITIALIZED = 0x00000008, /// Initial layout used when the data is populated by the CPU
+
+ //@extension("VK_KHR_swapchain")
+- VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 0xc0000802,
++ VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
+ }
+
+ enum VkAttachmentLoadOp {
+@@ -623,14 +623,15 @@ enum VkStructureType {
+ VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 47,
+
+ //@extension("VK_KHR_swapchain")
+- VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 0xc0000801,
++ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
++ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
+
+ //@extension("VK_KHR_display")
+- VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 0xc0000c00,
+- VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 0xc0000c01,
++ VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
++ VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
+
+ //@extension("VK_KHR_display_swapchain")
+- VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR = 0xc0001000,
++ VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR = 1000003000,
+ }
+
+ enum VkSubpassContents {
+@@ -638,44 +639,44 @@ enum VkSubpassContents {
+ VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 0x00000001,
+ }
+
+-@lastUnused(-10)
++@lastUnused(-11)
+ /// Error and return codes
+ enum VkResult {
+ // Return codes for successful operation execution (positive values)
+- VK_SUCCESS = 0x00000000,
+- VK_NOT_READY = 0x00000001,
+- VK_TIMEOUT = 0x00000002,
+- VK_EVENT_SET = 0x00000003,
+- VK_EVENT_RESET = 0x00000004,
+- VK_INCOMPLETE = 0x00000005,
++ VK_SUCCESS = 0,
++ VK_NOT_READY = 1,
++ VK_TIMEOUT = 2,
++ VK_EVENT_SET = 3,
++ VK_EVENT_RESET = 4,
++ VK_INCOMPLETE = 5,
+
+ //@extension("VK_KHR_swapchain")
+- VK_SUBOPTIMAL_KHR = 0x40000403,
++ VK_SUBOPTIMAL_KHR = 1000001003,
+
+ // Error codes (negative values)
+- VK_ERROR_OUT_OF_HOST_MEMORY = 0xFFFFFFFF,
+- VK_ERROR_OUT_OF_DEVICE_MEMORY = 0xFFFFFFFE,
+- VK_ERROR_INITIALIZATION_FAILED = 0xFFFFFFFD,
+- VK_ERROR_DEVICE_LOST = 0xFFFFFFFC,
+- VK_ERROR_MEMORY_MAP_FAILED = 0xFFFFFFFB,
+- VK_ERROR_LAYER_NOT_PRESENT = 0xFFFFFFFA,
+- VK_ERROR_EXTENSION_NOT_PRESENT = 0xFFFFFFF9,
+- VK_ERROR_FEATURE_NOT_PRESENT = 0xFFFFFFF8,
+- VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF7,
+- VK_ERROR_TOO_MANY_OBJECTS = 0xFFFFFFF6,
+- VK_ERROR_FORMAT_NOT_SUPPORTED = 0xFFFFFFF5,
++ VK_ERROR_OUT_OF_HOST_MEMORY = 0xFFFFFFFF, // -1
++ VK_ERROR_OUT_OF_DEVICE_MEMORY = 0xFFFFFFFE, // -2
++ VK_ERROR_INITIALIZATION_FAILED = 0xFFFFFFFD, // -3
++ VK_ERROR_DEVICE_LOST = 0xFFFFFFFC, // -4
++ VK_ERROR_MEMORY_MAP_FAILED = 0xFFFFFFFB, // -5
++ VK_ERROR_LAYER_NOT_PRESENT = 0xFFFFFFFA, // -6
++ VK_ERROR_EXTENSION_NOT_PRESENT = 0xFFFFFFF9, // -7
++ VK_ERROR_FEATURE_NOT_PRESENT = 0xFFFFFFF8, // -8
++ VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF7, // -9
++ VK_ERROR_TOO_MANY_OBJECTS = 0xFFFFFFF6, // -10
++ VK_ERROR_FORMAT_NOT_SUPPORTED = 0xFFFFFFF5, // -11
+
+ //@extension("VK_KHR_surface")
+- VK_ERROR_SURFACE_LOST_KHR = 0xC0000400,
++ VK_ERROR_SURFACE_LOST_KHR = 0xC4653600, // -1000000000
+
+ //@extension("VK_KHR_swapchain")
+- VK_ERROR_OUT_OF_DATE_KHR = 0xC0000804,
++ VK_ERROR_OUT_OF_DATE_KHR = 0xC4653214, // -1000001004
+
+ //@extension("VK_KHR_display_swapchain")
+- VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC0001001,
++ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC4652A47, // -1000003001
+
+ //@extension("VK_KHR_android_surface")
+- VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = 0xC0002400,
++ VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = 0xC46516C0, // -1000008000
+ }
+
+ enum VkDynamicState {
+diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
+index 598d98e..fa58c59 100644
+--- a/vulkan/include/vulkan/vulkan.h
++++ b/vulkan/include/vulkan/vulkan.h
+@@ -41,7 +41,7 @@ extern "C" {
+ ((major << 22) | (minor << 12) | patch)
+
+ // Vulkan API version supported by this file
+-#define VK_API_VERSION VK_MAKE_VERSION(0, 210, 0)
++#define VK_API_VERSION VK_MAKE_VERSION(0, 210, 1)
+
+
+ #define VK_NULL_HANDLE 0
+@@ -125,11 +125,11 @@ typedef enum VkResult {
+ VK_ERROR_INCOMPATIBLE_DRIVER = -9,
+ VK_ERROR_TOO_MANY_OBJECTS = -10,
+ VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
+- VK_ERROR_SURFACE_LOST_KHR = 0xC0000400,
+- VK_SUBOPTIMAL_KHR = 0x40000403,
+- VK_ERROR_OUT_OF_DATE_KHR = 0xC0000804,
+- VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = 0xC0001001,
+- VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = 0xC0002400,
++ VK_ERROR_SURFACE_LOST_KHR = -1000000000,
++ VK_SUBOPTIMAL_KHR = 1000001003,
++ VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
++ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
++ VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000008000,
+ VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED,
+ VK_RESULT_END_RANGE = VK_INCOMPLETE,
+ VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + 1),
+@@ -185,11 +185,11 @@ typedef enum VkStructureType {
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45,
+ VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 46,
+ VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 47,
+- VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 0xC0000800,
+- VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 0xC0000801,
+- VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 0xC0000C00,
+- VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 0xC0000C01,
+- VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 0xC0001000,
++ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
++ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
++ VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
++ VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
++ VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
+ VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+ VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
+ VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+@@ -468,7 +468,7 @@ typedef enum VkImageLayout {
+ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
+ VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
+- VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 0xC0000802,
++ VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
+ VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
+ VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
+ VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
+diff --git a/vulkan/libvulkan/Android.mk b/vulkan/libvulkan/Android.mk
+index 2f809c2..7a2eb64 100644
+--- a/vulkan/libvulkan/Android.mk
++++ b/vulkan/libvulkan/Android.mk
+@@ -25,10 +25,6 @@ LOCAL_CPPFLAGS := -std=c++1y \
+ -Wno-c99-extensions \
+ -Wno-zero-length-array
+
+-# TODO(jessehall): Very temporary, until VkResult values are defined as signed integers
+-# rather than unsigned hex values.
+-LOCAL_CFLAGS += -Wno-error=format
+-
+ LOCAL_C_INCLUDES := \
+ frameworks/native/vulkan/include \
+ system/core/libsync/include
+diff --git a/vulkan/tools/Android.mk b/vulkan/tools/Android.mk
+index 2c2309f..31d6089 100644
+--- a/vulkan/tools/Android.mk
++++ b/vulkan/tools/Android.mk
+@@ -23,10 +23,6 @@ LOCAL_CPPFLAGS := -std=c++1y \
+ -Wno-c++98-compat-pedantic \
+ -Wno-c99-extensions
+
+-# TODO(jessehall): Very temporary, until VkResult values are defined as signed integers
+-# rather than unsigned hex values.
+-LOCAL_CFLAGS += -Wno-error=format
+-
+ LOCAL_C_INCLUDES := \
+ frameworks/native/vulkan/include
+
+--
+2.4.0
+
OSDN Git Service
