diff --git a/vulkan/api/templates/vulkan_common.tmpl b/vulkan/api/templates/vulkan_common.tmpl
index ce37a13..f694c56 100644
--- a/vulkan/api/templates/vulkan_common.tmpl
+++ b/vulkan/api/templates/vulkan_common.tmpl
@@ -216,7 +216,8 @@
 {{define "Vtbl"}}
   {{AssertType $ "Function"}}
 
-  {{range $i, $p := $.CallParameters}}
-    {{if not $i}}{{Node "Vtbl" $p}}{{end}}
+  {{if gt (len $.CallParameters) 0}}
+    {{Node "Vtbl" (index $.CallParameters 0)}}
+  {{else}}Global
   {{end}}
 {{end}}
diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
index 0d56145..b74062f 100644
--- a/vulkan/api/vulkan.api
+++ b/vulkan/api/vulkan.api
@@ -26,9 +26,9 @@
 ///////////////
 
 // API version (major.minor.patch)
-define VERSION_MAJOR 0
-define VERSION_MINOR 210
-define VERSION_PATCH 1
+define VERSION_MAJOR 1
+define VERSION_MINOR 0
+define VERSION_PATCH 0
 
 // API limits
 define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256
@@ -45,44 +45,34 @@
 // API keyword, but needs special handling by some templates
 define NULL_HANDLE 0
 
-@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_SPEC_VERSION                 24
 @extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NAME               "VK_KHR_surface"
 
-@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_SPEC_VERSION             67
 @extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NAME           "VK_KHR_swapchain"
 
-@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_SPEC_VERSION                 21
 @extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NAME               "VK_KHR_display"
 
-@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_SPEC_VERSION     9
 @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           5
-@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_NUMBER             5
+@extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_SPEC_VERSION       6
 @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             5
-@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_NUMBER               6
+@extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_SPEC_VERSION         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     4
-@extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_NUMBER       7
+@extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 5
 @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             4
-@extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_NUMBER               8
+@extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_SPEC_VERSION         4
 @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     4
-@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_NUMBER       8
+@extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 5
 @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         4
-@extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_NUMBER           9
+@extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_SPEC_VERSION     5
 @extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_NAME             "VK_KHR_win32_surface"
 
 
@@ -262,7 +252,6 @@
 }
 
 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
 }
@@ -614,13 +603,14 @@
     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO                   = 38,
     VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO                  = 39,
     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_LOADER_INSTANCE_CREATE_INFO               = 46,
-    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO                 = 47,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_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_LOADER_INSTANCE_CREATE_INFO               = 47,
+    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO                 = 48,
 
     //@extension("VK_KHR_swapchain")
     VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR                 = 1000001000,
@@ -632,6 +622,27 @@
 
     //@extension("VK_KHR_display_swapchain")
     VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR          = 1000003000,
+
+    //@extension("VK_KHR_xlib_surface")
+    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR              = 1000004000,
+
+    //@extension("VK_KHR_xcb_surface")
+    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR               = 1000005000,
+
+    //@extension("VK_KHR_wayland_surface")
+    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR           = 1000006000,
+
+    //@extension("VK_KHR_mir_surface")
+    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR               = 1000007000,
+
+    //@extension("VK_KHR_android_surface")
+    VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR           = 1000008000,
+
+    //@extension("VK_KHR_win32_surface")
+    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR             = 1000009000,
+
+    //@extension("VK_EXT_debug_report")
+    VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT              = 1000011000,
 }
 
 enum VkSubpassContents {
@@ -639,6 +650,10 @@
     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS           = 0x00000001,
 }
 
+enum VkPipelineCacheHeaderVersion {
+    VK_PIPELINE_CACHE_HEADER_VERSION_ONE                    = 1,
+}
+
 @lastUnused(-11)
 /// Error and return codes
 enum VkResult {
@@ -677,6 +692,9 @@
 
     //@extension("VK_KHR_android_surface")
     VK_ERROR_NATIVE_WINDOW_IN_USE_KHR                       = 0xC46516C0, // -1000008000
+
+    //@extension("VK_EXT_debug_report")
+    VK_ERROR_VALIDATION_FAILED_EXT                          = 0xC4650B07, // -1000011001
 }
 
 enum VkDynamicState {
@@ -884,7 +902,6 @@
 /// Query result flags
 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
     VK_QUERY_RESULT_WITH_AVAILABILITY_BIT                   = 0x00000004,   /// Besides the results of the query, the availability of the results is also written
@@ -969,10 +986,11 @@
     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT           = 0x00000400,  /// Color attachment writes
     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT                    = 0x00000800,  /// Compute shading
     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_BOTTOM_OF_PIPE_BIT                    = 0x00002000,
+    VK_PIPELINE_STAGE_HOST_BIT                              = 0x00004000,  /// Indicates host (CPU) is a source/sink of the dependency
 
-    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
+    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT                      = 0x00008000,  /// All stages of the graphics pipeline
+    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT                      = 0x00010000,  /// All graphics, compute, copy, and transition commands
 }
 
 /// Render pass attachment description flags
@@ -1017,7 +1035,6 @@
 
 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
     VK_STENCIL_FRONT_AND_BACK                               = 0x00000003,
@@ -1147,7 +1164,7 @@
 type VkFlags VkSurfaceTransformFlagsKHR
 @extension("VK_KHR_surface")
 bitfield VkSurfaceTransformFlagBitsKHR {
-    VK_SURFACE_TRANSFORM_NONE_BIT_KHR                           = 0x00000001,
+    VK_SURFACE_TRANSFORM_IDENTITY_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,
@@ -1196,6 +1213,42 @@
 //bitfield VkDisplayModeCreateFlagBitsKHR {
 //}
 
+@extension("VK_KHR_xlib_surface")
+type VkFlags VkXlibSurfaceCreateFlagsKHR
+//@extension("VK_KHR_xlib_surface")
+//bitfield VkXlibSurfaceCreateFlagBitsKHR {
+//}
+
+@extension("VK_KHR_xcb_surface")
+type VkFlags VkXcbSurfaceCreateFlagsKHR
+//@extension("VK_KHR_xcb_surface")
+//bitfield VkXcbSurfaceCreateFlagBitsKHR {
+//}
+
+@extension("VK_KHR_wayland_surface")
+type VkFlags VkWaylandSurfaceCreateFlagsKHR
+//@extension("VK_KHR_wayland_surface")
+//bitfield VkWaylandSurfaceCreateFlagBitsKHR {
+//}
+
+@extension("VK_KHR_mir_surface")
+type VkFlags VkMirSurfaceCreateFlagsKHR
+//@extension("VK_KHR_mir_surface")
+//bitfield VkMirSurfaceCreateFlagBitsKHR {
+//}
+
+@extension("VK_KHR_android_surface")
+type VkFlags VkAndroidSurfaceCreateFlagsKHR
+//@extension("VK_KHR_android_surface")
+//bitfield VkAndroidSurfaceCreateFlagBitsKHR {
+//}
+
+@extension("VK_KHR_win32_surface")
+type VkFlags VkWin32SurfaceCreateFlagsKHR
+//@extension("VK_KHR_win32_surface")
+//bitfield VkWin32SurfaceCreateFlagBitsKHR {
+//}
+
 
 //////////////////
 //  Structures  //
@@ -1213,14 +1266,14 @@
 }
 
 class VkExtent2D {
-    s32                                         width
-    s32                                         height
+    u32                                         width
+    u32                                         height
 }
 
 class VkExtent3D {
-    s32                                         width
-    s32                                         height
-    s32                                         depth
+    u32                                         width
+    u32                                         height
+    u32                                         depth
 }
 
 class VkViewport {
@@ -1279,6 +1332,7 @@
     const void*                                 pNext              /// Next structure in chain
     u32                                         waitSemaphoreCount
     const VkSemaphore*                          pWaitSemaphores
+    const VkPipelineStageFlags*                 pWaitDstStageMask
     u32                                         commandBufferCount
     const VkCommandBuffer*                      pCommandBuffers
     u32                                         signalSemaphoreCount
@@ -1319,9 +1373,9 @@
     VkDeviceCreateFlags                         flags
     u32                                         queueCreateInfoCount
     const VkDeviceQueueCreateInfo*              pQueueCreateInfos
-    u32                                         enabledLayerNameCount
+    u32                                         enabledLayerCount
     const char* const*                          ppEnabledLayerNames        /// Ordered list of layer names to be enabled
-    u32                                         enabledExtensionNameCount
+    u32                                         enabledExtensionCount
     const char* const*                          ppEnabledExtensionNames
     const VkPhysicalDeviceFeatures*             pEnabledFeatures
 }
@@ -1331,9 +1385,9 @@
     const void*                                 pNext                      /// Pointer to next structure
     VkInstanceCreateFlags                       flags
     const VkApplicationInfo*                    pApplicationInfo
-    u32                                         enabledLayerNameCount
+    u32                                         enabledLayerCount
     const char* const*                          ppEnabledLayerNames        /// Ordered list of layer names to be enabled
-    u32                                         enabledExtensionNameCount
+    u32                                         enabledExtensionCount
     const char* const*                          ppEnabledExtensionNames    /// Extension names to be enabled
 }
 
@@ -1372,7 +1426,7 @@
 
 class VkSparseImageMemoryRequirements {
     VkSparseImageFormatProperties               formatProperties
-    u32                                         imageMipTailStartLod
+    u32                                         imageMipTailFirstLod
     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,6 +1590,7 @@
     VkDeviceSize                                offset                 /// Specified in bytes
     VkDeviceSize                                size                   /// Specified in bytes
     VkDeviceSize                                rowPitch               /// Specified in bytes
+    VkDeviceSize                                arrayPitch             /// Specified in bytes
     VkDeviceSize                                depthPitch             /// Specified in bytes
 }
 
@@ -1623,11 +1678,9 @@
 
 class VkImageBlit {
     VkImageSubresourceLayers                    srcSubresource
-    VkOffset3D                                  srcOffset              /// Specified in pixels for both compressed and uncompressed images
-    VkExtent3D                                  srcExtent              /// Specified in pixels for both compressed and uncompressed images
+    VkOffset3D[2]                               srcOffsets
     VkImageSubresourceLayers                    dstSubresource
-    VkOffset3D                                  dstOffset              /// Specified in pixels for both compressed and uncompressed images
-    VkExtent3D                                  dstExtent              /// Specified in pixels for both compressed and uncompressed images
+    VkOffset3D[2]                               dstOffsets
 }
 
 class VkBufferImageCopy {
@@ -1668,7 +1721,7 @@
     const void*                                 pNext              /// Pointer to next structure
     VkDescriptorSetLayoutCreateFlags            flags
     u32                                         bindingCount       /// Number of bindings in the descriptor set layout
-    const VkDescriptorSetLayoutBinding*         pBinding           /// Array of descriptor set layout bindings
+    const VkDescriptorSetLayoutBinding*         pBindings          /// Array of descriptor set layout bindings
 }
 
 class VkDescriptorPoolSize {
@@ -1897,7 +1950,7 @@
     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
+    u32                                         descriptorSetCount      /// 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
@@ -1914,6 +1967,7 @@
     VkSamplerAddressMode                        addressModeV
     VkSamplerAddressMode                        addressModeW
     f32                                         mipLodBias
+    VkBool32                                    anisotropyEnable
     f32                                         maxAnisotropy
     VkBool32                                    compareEnable
     VkCompareOp                                 compareOp
@@ -1935,13 +1989,12 @@
     const void*                                 pNext      /// Pointer to next structure
     VkCommandPool                               commandPool
     VkCommandBufferLevel                        level
-    u32                                         bufferCount
+    u32                                         commandBufferCount
 }
 
-class VkCommandBufferBeginInfo {
-    VkStructureType                             sType       /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
+class VkCommandBufferInheritanceInfo {
+    VkStructureType                             sType       /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO
     const void*                                 pNext       /// Pointer to next structure
-    VkCommandBufferUsageFlags                   flags       /// Command buffer usage flags
     VkRenderPass                                renderPass  /// Render pass for secondary command buffers
     u32                                         subpass
     VkFramebuffer                               framebuffer /// Framebuffer for secondary command buffers
@@ -1950,6 +2003,13 @@
     VkQueryPipelineStatisticFlags               pipelineStatistics
 }
 
+class VkCommandBufferBeginInfo {
+    VkStructureType                             sType       /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
+    const void*                                 pNext       /// Pointer to next structure
+    VkCommandBufferUsageFlags                   flags       /// Command buffer usage flags
+    const VkCommandBufferInheritanceInfo*       pInheritanceInfo
+}
+
 class VkRenderPassBeginInfo {
     VkStructureType                             sType       /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
     const void*                                 pNext       /// Pointer to next structure
@@ -2013,7 +2073,7 @@
     const VkAttachmentReference*                pResolveAttachments
     const VkAttachmentReference*                pDepthStencilAttachment
     u32                                         preserveAttachmentCount
-    const VkAttachmentReference*                pPreserveAttachments
+    const u32*                                  pPreserveAttachments
 }
 
 class VkSubpassDependency {
@@ -2061,6 +2121,7 @@
     VkBool32                                    dualSrcBlend                              /// blend operations which take two sources
     VkBool32                                    logicOp                                   /// logic operations
     VkBool32                                    multiDrawIndirect                         /// multi draw indirect
+    VkBool32                                    drawIndirectFirstInstance
     VkBool32                                    depthClamp                                /// depth clamping
     VkBool32                                    depthBiasClamp                            /// depth bias clamping
     VkBool32                                    fillModeNonSolid                          /// point and wireframe fill modes
@@ -2104,6 +2165,7 @@
     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
+    VkBool32                                    inheritedQueries
 }
 
 class VkPhysicalDeviceLimits {
@@ -2214,6 +2276,7 @@
     VkSampleCountFlags                          sampledImageStencilSampleCounts
     VkSampleCountFlags                          storageImageSampleCounts
     u32                                         maxSampleMaskWords                        /// max num of sample mask words
+    VkBool32                                    timestampComputeAndGraphics
 
     f32                                         timestampPeriod
 
@@ -2254,7 +2317,7 @@
     const void*                                 pNext              /// Pointer to next structure
     VkQueryPoolCreateFlags                      flags
     VkQueryType                                 queryType
-    u32                                         entryCount
+    u32                                         queryCount
     VkQueryPipelineStatisticFlags               pipelineStatistics /// Optional
 }
 
@@ -2418,6 +2481,59 @@
     VkBool32                                    persistent
 }
 
+@extension("VK_KHR_xlib_surface")
+class VkXlibSurfaceCreateInfoKHR {
+    VkStructureType                             sType
+    const void*                                 pNext
+    VkXlibSurfaceCreateFlagsKHR                 flags
+    platform.Display*                           dpy
+    platform.Window                             window
+}
+
+@extension("VK_KHR_xcb_surface")
+class VkXcbSurfaceCreateInfoKHR {
+    VkStructureType                             sType
+    const void*                                 pNext
+    VkXcbSurfaceCreateFlagsKHR                  flags
+    platform.xcb_connection_t*                  connection
+    platform.xcb_window_t                       window
+}
+
+@extension("VK_KHR_wayland_surface")
+class VkWaylandSurfaceCreateInfoKHR {
+    VkStructureType                             sType
+    const void*                                 pNext
+    VkWaylandSurfaceCreateFlagsKHR              flags
+    platform.wl_display*                        display
+    platform.wl_surface*                        surface
+}
+
+@extension("VK_KHR_mir_surface")
+class VkMirSurfaceCreateInfoKHR {
+    VkStructureType                             sType
+    const void*                                 pNext
+    VkMirSurfaceCreateFlagsKHR                  flags
+    platform.MirConnection*                     connection
+    platform.MirSurface*                        mirSurface
+}
+
+@extension("VK_KHR_android_surface")
+class VkAndroidSurfaceCreateInfoKHR {
+    VkStructureType                             sType
+    const void*                                 pNext
+    VkAndroidSurfaceCreateFlagsKHR              flags
+    platform.ANativeWindow*                     window
+}
+
+@extension("VK_KHR_win32_surface")
+class VkWin32SurfaceCreateInfoKHR {
+    VkStructureType                             sType
+    const void*                                 pNext
+    VkWin32SurfaceCreateFlagsKHR                flags
+    platform.HINSTANCE                          hinstance
+    platform.HWND                               hwnd
+}
+
 
 ////////////////
 //  Commands  //
@@ -2483,8 +2599,8 @@
     pInstance[0] = instance
     State.Instances[instance] = new!InstanceObject()
 
-    layers := pCreateInfo.ppEnabledLayerNames[0:pCreateInfo.enabledLayerNameCount]
-    extensions := pCreateInfo.ppEnabledExtensionNames[0:pCreateInfo.enabledExtensionNameCount]
+    layers := pCreateInfo.ppEnabledLayerNames[0:pCreateInfo.enabledLayerCount]
+    extensions := pCreateInfo.ppEnabledExtensionNames[0:pCreateInfo.enabledExtensionCount]
 
     return ?
 }
@@ -3204,7 +3320,7 @@
 cmd VkResult vkGetQueryPoolResults(
         VkDevice                                    device,
         VkQueryPool                                 queryPool,
-        u32                                         startQuery,
+        u32                                         firstQuery,
         u32                                         queryCount,
         platform.size_t                             dataSize,
         void*                                       pData,
@@ -3847,7 +3963,7 @@
         VkCommandBuffer*                            pCommandBuffers) {
     assert(pAllocateInfo[0].sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO)
 
-    count := pAllocateInfo[0].bufferCount
+    count := pAllocateInfo[0].commandBufferCount
     commandBuffers := pCommandBuffers[0:count]
     for i in (0 .. count) {
         commandBuffer := ?
@@ -3928,6 +4044,7 @@
 @threadSafety("app")
 cmd void vkCmdSetViewport(
         VkCommandBuffer                             commandBuffer,
+        u32                                         firstViewport,
         u32                                         viewportCount,
         const VkViewport*                           pViewports) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
@@ -3937,6 +4054,7 @@
 @threadSafety("app")
 cmd void vkCmdSetScissor(
         VkCommandBuffer                             commandBuffer,
+        u32                                         firstScissor,
         u32                                         scissorCount,
         const VkRect2D*                             pScissors) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
@@ -4057,13 +4175,13 @@
 @threadSafety("app")
 cmd void vkCmdBindVertexBuffers(
         VkCommandBuffer                             commandBuffer,
-        u32                                         startBinding,
+        u32                                         firstBinding,
         u32                                         bindingCount,
         const VkBuffer*                             pBuffers,
         const VkDeviceSize*                         pOffsets) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
 
-    // TODO: check if not [startBinding:startBinding+bindingCount]
+    // TODO: check if not [firstBinding:firstBinding+bindingCount]
     buffers := pBuffers[0:bindingCount]
     offsets := pOffsets[0:bindingCount]
     for i in (0 .. bindingCount) {
@@ -4434,7 +4552,11 @@
         VkPipelineStageFlags                        srcStageMask,
         VkPipelineStageFlags                        dstStageMask,
         u32                                         memoryBarrierCount,
-        const void* const*                          ppMemoryBarriers) {
+        const VkMemoryBarrier*                      pMemoryBarriers,
+        u32                                         bufferMemoryBarrierCount,
+        const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
+        u32                                         imageMemoryBarrierCount,
+        const VkImageMemoryBarrier*                 pImageMemoryBarriers) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
 
     events := pEvents[0:eventCount]
@@ -4444,23 +4566,21 @@
         assert(commandBufferObject.device == eventObject.device)
     }
 
-    pMemoryBarriers := ppMemoryBarriers[0:memoryBarrierCount]
+    memoryBarriers := pMemoryBarriers[0:memoryBarrierCount]
     for i in (0 .. memoryBarrierCount) {
-        switch as!VkMemoryBarrier const*(pMemoryBarriers[i])[0].sType {
-            case VK_STRUCTURE_TYPE_MEMORY_BARRIER: {
-                memoryBarrier := as!VkMemoryBarrier const*(pMemoryBarriers[i])[0]
-            }
-            case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: {
-                imageMemoryBarrier := as!VkImageMemoryBarrier const*(pMemoryBarriers[i])[0]
-                imageObject := GetImage(imageMemoryBarrier.image)
-                assert(imageObject.device == commandBufferObject.device)
-            }
-            case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: {
-                bufferMemoryBarrier := as!VkBufferMemoryBarrier const*(pMemoryBarriers[i])[0]
-                bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
-                assert(bufferObject.device == commandBufferObject.device)
-            }
-        }
+        memoryBarrier := memoryBarriers[i]
+    }
+    bufferMemoryBarriers := pBufferMemoryBarriers[0:bufferMemoryBarrierCount]
+    for i in (0 .. bufferMemoryBarrierCount) {
+        bufferMemoryBarrier := bufferMemoryBarriers[i]
+        bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
+        assert(bufferObject.device == commandBufferObject.device)
+    }
+    imageMemoryBarriers := pImageMemoryBarriers[0:imageMemoryBarrierCount]
+    for i in (0 .. imageMemoryBarrierCount) {
+        imageMemoryBarrier := imageMemoryBarriers[i]
+        imageObject := GetImage(imageMemoryBarrier.image)
+        assert(imageObject.device == commandBufferObject.device)
     }
 }
 
@@ -4471,26 +4591,28 @@
         VkPipelineStageFlags                        dstStageMask,
         VkDependencyFlags                           dependencyFlags,
         u32                                         memoryBarrierCount,
-        const void* const*                          ppMemoryBarriers) {
+        const VkMemoryBarrier*                      pMemoryBarriers,
+        u32                                         bufferMemoryBarrierCount,
+        const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
+        u32                                         imageMemoryBarrierCount,
+        const VkImageMemoryBarrier*                 pImageMemoryBarriers) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
 
-    pMemoryBarriers := ppMemoryBarriers[0:memoryBarrierCount]
+    memoryBarriers := pMemoryBarriers[0:memoryBarrierCount]
     for i in (0 .. memoryBarrierCount) {
-        switch as!VkMemoryBarrier const*(pMemoryBarriers[i])[0].sType {
-            case VK_STRUCTURE_TYPE_MEMORY_BARRIER: {
-                memoryBarrier := as!VkMemoryBarrier const*(pMemoryBarriers[i])[0]
-            }
-            case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: {
-                imageMemoryBarrier := as!VkImageMemoryBarrier const*(pMemoryBarriers[i])[0]
-                imageObject := GetImage(imageMemoryBarrier.image)
-                assert(imageObject.device == commandBufferObject.device)
-            }
-            case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: {
-                bufferMemoryBarrier := as!VkBufferMemoryBarrier const*(pMemoryBarriers[i])[0]
-                bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
-                assert(bufferObject.device == commandBufferObject.device)
-            }
-        }
+        memoryBarrier := memoryBarriers[i]
+    }
+    bufferMemoryBarriers := pBufferMemoryBarriers[0:bufferMemoryBarrierCount]
+    for i in (0 .. bufferMemoryBarrierCount) {
+        bufferMemoryBarrier := bufferMemoryBarriers[i]
+        bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
+        assert(bufferObject.device == commandBufferObject.device)
+    }
+    imageMemoryBarriers := pImageMemoryBarriers[0:imageMemoryBarrierCount]
+    for i in (0 .. imageMemoryBarrierCount) {
+        imageMemoryBarrier := imageMemoryBarriers[i]
+        imageObject := GetImage(imageMemoryBarrier.image)
+        assert(imageObject.device == commandBufferObject.device)
     }
 }
 
@@ -4498,7 +4620,7 @@
 cmd void vkCmdBeginQuery(
         VkCommandBuffer                             commandBuffer,
         VkQueryPool                                 queryPool,
-        u32                                         entry,
+        u32                                         query,
         VkQueryControlFlags                         flags) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     queryPoolObject := GetQueryPool(queryPool)
@@ -4509,7 +4631,7 @@
 cmd void vkCmdEndQuery(
         VkCommandBuffer                             commandBuffer,
         VkQueryPool                                 queryPool,
-        u32                                         entry) {
+        u32                                         query) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     queryPoolObject := GetQueryPool(queryPool)
     assert(commandBufferObject.device == queryPoolObject.device)
@@ -4519,7 +4641,7 @@
 cmd void vkCmdResetQueryPool(
         VkCommandBuffer                             commandBuffer,
         VkQueryPool                                 queryPool,
-        u32                                         startQuery,
+        u32                                         firstQuery,
         u32                                         queryCount) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     queryPoolObject := GetQueryPool(queryPool)
@@ -4531,7 +4653,7 @@
         VkCommandBuffer                             commandBuffer,
         VkPipelineStageFlagBits                     pipelineStage,
         VkQueryPool                                 queryPool,
-        u32                                         entry) {
+        u32                                         query) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     queryPoolObject := GetQueryPool(queryPool)
     assert(commandBufferObject.device == queryPoolObject.device)
@@ -4541,7 +4663,7 @@
 cmd void vkCmdCopyQueryPoolResults(
         VkCommandBuffer                             commandBuffer,
         VkQueryPool                                 queryPool,
-        u32                                         startQuery,
+        u32                                         firstQuery,
         u32                                         queryCount,
         VkBuffer                                    dstBuffer,
         VkDeviceSize                                dstOffset,
@@ -4596,12 +4718,12 @@
 
 cmd void vkCmdExecuteCommands(
         VkCommandBuffer                             commandBuffer,
-        u32                                         commandBuffersCount,
+        u32                                         commandBufferCount,
         const VkCommandBuffer*                      pCommandBuffers) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
 
-    commandBuffers := pCommandBuffers[0:commandBuffersCount]
-    for i in (0 .. commandBuffersCount) {
+    commandBuffers := pCommandBuffers[0:commandBufferCount]
+    for i in (0 .. commandBufferCount) {
         secondaryCommandBuffer := commandBuffers[i]
         secondaryCommandBufferObject := GetCommandBuffer(secondaryCommandBuffer)
         assert(commandBufferObject.device == secondaryCommandBufferObject.device)
@@ -4783,6 +4905,7 @@
 @extension("VK_KHR_display")
 cmd VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
         VkPhysicalDevice                        physicalDevice,
+        u32                                     planeIndex,
         u32*                                    pDisplayCount,
         VkDisplayKHR*                           pDisplays) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
@@ -4842,8 +4965,7 @@
 @extension("VK_KHR_xlib_surface")
 cmd VkResult vkCreateXlibSurfaceKHR(
         VkInstance                              instance,
-        platform.Display*                       dpy,
-        platform.Window                         window,
+        const VkXlibSurfaceCreateInfoKHR*       pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
@@ -4861,10 +4983,9 @@
 }
 
 @extension("VK_KHR_xcb_surface")
-cmd VkResult vkCreateXCBSurfaceKHR(
+cmd VkResult vkCreateXcbSurfaceKHR(
         VkInstance                              instance,
-        platform.xcb_connection_t*              connection,
-        platform.xcb_window_t                   window,
+        const VkXcbSurfaceCreateInfoKHR*        pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
@@ -4884,8 +5005,7 @@
 @extension("VK_KHR_wayland_surface")
 cmd VkResult vkCreateWaylandSurfaceKHR(
         VkInstance                              instance,
-        platform.wl_display*                    display,
-        platform.wl_surface*                    surface,
+        const VkWaylandSurfaceCreateInfoKHR*    pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
@@ -4904,8 +5024,7 @@
 @extension("VK_KHR_mir_surface")
 cmd VkResult vkCreateMirSurfaceKHR(
         VkInstance                              instance,
-        platform.MirConnection*                 connection,
-        platform.MirSurface*                    mirSurface,
+        const VkMirSurfaceCreateInfoKHR*        pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
@@ -4924,7 +5043,7 @@
 @extension("VK_KHR_android_surface")
 cmd VkResult vkCreateAndroidSurfaceKHR(
         VkInstance                              instance,
-        platform.ANativeWindow*                 window,
+        const VkAndroidSurfaceCreateInfoKHR*    pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
@@ -4934,8 +5053,7 @@
 @extension("VK_KHR_win32_surface")
 cmd VkResult vkCreateWin32SurfaceKHR(
         VkInstance                              instance,
-        platform.HINSTANCE                      hinstance,
-        platform.HWND                           hwnd,
+        const VkWin32SurfaceCreateInfoKHR*      pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
diff --git a/vulkan/doc/DevelopersGuide.pdf b/vulkan/doc/DevelopersGuide.pdf
index 5b9918c..cf009c5 100644
--- a/vulkan/doc/DevelopersGuide.pdf
+++ b/vulkan/doc/DevelopersGuide.pdf
Binary files differ
diff --git a/vulkan/doc/implementors_guide/implementors_guide.adoc b/vulkan/doc/implementors_guide/implementors_guide.adoc
index 60a6f61..97eff48 100644
--- a/vulkan/doc/implementors_guide/implementors_guide.adoc
+++ b/vulkan/doc/implementors_guide/implementors_guide.adoc
@@ -2,7 +2,7 @@
 = Vulkan on Android Implementor's Guide =
 :toc: right
 :numbered:
-:revnumber: 3
+:revnumber: 4
 
 This document is intended for GPU IHVs writing Vulkan drivers for Android, and OEMs integrating them for specific devices. It describes how a Vulkan driver interacts with the system, how GPU-specific tools should be installed, and Android-specific requirements.
 
@@ -99,7 +99,9 @@
   .pQueueFamilyIndices = VkSwapChainCreateInfoWSI::pQueueFamilyIndices
 ----
 
-+vkAcquireImageANDROID+ acquires ownership of a swapchain image and imports an externally-signalled native fence into an existing +VkSemaphore+ object:
++vkAcquireImageANDROID+ acquires ownership of a swapchain image and imports an
+externally-signalled native fence into both an existing VkSemaphore object
+and an existing VkFence object:
 
 [source,c]
 ----
@@ -107,12 +109,26 @@
     VkDevice            device,
     VkImage             image,
     int                 nativeFenceFd,
-    VkSemaphore         semaphore
-);
+    VkSemaphore         semaphore,
+    VkFence             fence
 );
 ----
 
-This function is called during +vkAcquireNextImageWSI+ to import a native fence into the +VkSemaphore+ object provided by the application. The driver may also use this opportunity to recognize and handle any external changes to the gralloc buffer state; many drivers won't need to do anything here. This call puts the +VkSemaphore+ into the same "pending" state as +vkQueueSignalSemaphore+, so queues can wait on the semaphore. The +VkSemaphore+ signals when the underlying native fence signals; if the fence has already signalled, then the semaphore will be in the signalled state when this function returns. The driver takes ownership of the fence fd and is responsible for closing it when the +VkSemaphore+ is destroyed, when a different native fence is imported, or any other condition that replaces the +VkSemaphore+'s underlying synchronization object. If +fenceFd+ is -1, the +VkSemaphore+ will be considered signalled immediately, but it can still be passed to +vkQueueWaitSemaphore+.
+This function is called during +vkAcquireNextImageWSI+ to import a native
+fence into the +VkSemaphore+ and +VkFence+ objects provided by the
+application. Both semaphore and fence objects are optional in this call. The
+driver may also use this opportunity to recognize and handle any external
+changes to the gralloc buffer state; many drivers won't need to do anything
+here. This call puts the +VkSemaphore+ and +VkFence+ into the same "pending"
+state as +vkQueueSignalSemaphore+ and +vkQueueSubmit+ respectively, so queues
+can wait on the semaphore and the application can wait on the fence. Both
+objects become signalled when the underlying native fence signals; if the
+native fence has already signalled, then the semaphore will be in the signalled
+state when this function returns. The driver takes ownership of the fence fd
+and is responsible for closing it when no longer needed. It must do so even if
+neither a semaphore or fence object is provided, or even if
++vkAcquireImageANDROID+ fails and returns an error. If +fenceFd+ is -1, it
+is as if the native fence was already signalled.
 
 +vkQueueSignalReleaseImageANDROID+ prepares a swapchain image for external use, and creates a native fence and schedules it to be signalled when prior work on the queue has completed.
 
@@ -140,3 +156,6 @@
    * Replaced vkImportNativeFenceANDROID and vkQueueSignalNativeFenceANDROID
      with vkAcquireImageANDROID and vkQueueSignalReleaseImageANDROID, to allow
      drivers to known the ownership state of swapchain images.
+. *2015-12-03*
+   * Added a VkFence parameter to vkAcquireImageANDROID corresponding to the
+     parameter added to vkAcquireNextImageKHR.
diff --git a/vulkan/doc/implementors_guide/implementors_guide.html b/vulkan/doc/implementors_guide/implementors_guide.html
index 8d6297a..00efca8 100644
--- a/vulkan/doc/implementors_guide/implementors_guide.html
+++ b/vulkan/doc/implementors_guide/implementors_guide.html
@@ -843,7 +843,9 @@
   .queueFamilyCount    = VkSwapChainCreateInfoWSI::queueFamilyCount
   .pQueueFamilyIndices = VkSwapChainCreateInfoWSI::pQueueFamilyIndices</pre>
 </div></div>
-<div class="paragraph"><p><span class="monospaced">vkAcquireImageANDROID</span> acquires ownership of a swapchain image and imports an externally-signalled native fence into an existing <span class="monospaced">VkSemaphore</span> object:</p></div>
+<div class="paragraph"><p><span class="monospaced">vkAcquireImageANDROID</span> acquires ownership of a swapchain image and imports an
+externally-signalled native fence into both an existing VkSemaphore object
+and an existing VkFence object:</p></div>
 <div class="listingblock">
 <div class="content"><!-- Generator: GNU source-highlight 3.1.6
 by Lorenzo Bettini
@@ -853,10 +855,24 @@
     <span style="color: #008080">VkDevice</span>            device<span style="color: #990000">,</span>
     <span style="color: #008080">VkImage</span>             image<span style="color: #990000">,</span>
     <span style="color: #009900">int</span>                 nativeFenceFd<span style="color: #990000">,</span>
-    VkSemaphore         semaphore
-<span style="color: #990000">);</span>
+    <span style="color: #008080">VkSemaphore</span>         semaphore<span style="color: #990000">,</span>
+    VkFence             fence
 <span style="color: #990000">);</span></tt></pre></div></div>
-<div class="paragraph"><p>This function is called during <span class="monospaced">vkAcquireNextImageWSI</span> to import a native fence into the <span class="monospaced">VkSemaphore</span> object provided by the application. The driver may also use this opportunity to recognize and handle any external changes to the gralloc buffer state; many drivers won&#8217;t need to do anything here. This call puts the <span class="monospaced">VkSemaphore</span> into the same "pending" state as <span class="monospaced">vkQueueSignalSemaphore</span>, so queues can wait on the semaphore. The <span class="monospaced">VkSemaphore</span> signals when the underlying native fence signals; if the fence has already signalled, then the semaphore will be in the signalled state when this function returns. The driver takes ownership of the fence fd and is responsible for closing it when the <span class="monospaced">VkSemaphore</span> is destroyed, when a different native fence is imported, or any other condition that replaces the <span class="monospaced">VkSemaphore</span>'s underlying synchronization object. If <span class="monospaced">fenceFd</span> is -1, the <span class="monospaced">VkSemaphore</span> will be considered signalled immediately, but it can still be passed to <span class="monospaced">vkQueueWaitSemaphore</span>.</p></div>
+<div class="paragraph"><p>This function is called during <span class="monospaced">vkAcquireNextImageWSI</span> to import a native
+fence into the <span class="monospaced">VkSemaphore</span> and <span class="monospaced">VkFence</span> objects provided by the
+application. Both semaphore and fence objects are optional in this call. The
+driver may also use this opportunity to recognize and handle any external
+changes to the gralloc buffer state; many drivers won&#8217;t need to do anything
+here. This call puts the <span class="monospaced">VkSemaphore</span> and <span class="monospaced">VkFence</span> into the same "pending"
+state as <span class="monospaced">vkQueueSignalSemaphore</span> and <span class="monospaced">vkQueueSubmit</span> respectively, so queues
+can wait on the semaphore and the application can wait on the fence. Both
+objects become signalled when the underlying native fence signals; if the
+native fence has already signalled, then the semaphore will be in the signalled
+state when this function returns. The driver takes ownership of the fence fd
+and is responsible for closing it when no longer needed. It must do so even if
+neither a semaphore or fence object is provided, or even if
+<span class="monospaced">vkAcquireImageANDROID</span> fails and returns an error. If <span class="monospaced">fenceFd</span> is -1, it
+is as if the native fence was already signalled.</p></div>
 <div class="paragraph"><p><span class="monospaced">vkQueueSignalReleaseImageANDROID</span> prepares a swapchain image for external use, and creates a native fence and schedules it to be signalled when prior work on the queue has completed.</p></div>
 <div class="listingblock">
 <div class="content"><!-- Generator: GNU source-highlight 3.1.6
@@ -926,6 +942,19 @@
 </li>
 </ul></div>
 </li>
+<li>
+<p>
+<strong>2015-12-03</strong>
+</p>
+<div class="ulist"><ul>
+<li>
+<p>
+Added a VkFence parameter to vkAcquireImageANDROID corresponding to the
+     parameter added to vkAcquireNextImageKHR.
+</p>
+</li>
+</ul></div>
+</li>
 </ol></div>
 </div>
 </div>
@@ -934,7 +963,7 @@
 <div id="footer">
 <div id="footer-text">
 Version 3<br>
-Last updated 2015-11-04 10:58:22 PST
+Last updated 2015-12-03 15:47:36 PST
 </div>
 </div>
 </body>
diff --git a/vulkan/include/vulkan/vk_android_native_buffer.h b/vulkan/include/vulkan/vk_android_native_buffer.h
index bf4641e..744ed4a 100644
--- a/vulkan/include/vulkan/vk_android_native_buffer.h
+++ b/vulkan/include/vulkan/vk_android_native_buffer.h
@@ -17,21 +17,20 @@
 #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"
+#include <vulkan/vulkan.h>
 
 #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_ANDROID_native_buffer 1
+
+#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER 11
+#define VK_ANDROID_NATIVE_BUFFER_REVISION         4
+#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME   "VK_ANDROID_native_buffer"
+
+#define VK_ANDROID_NATIVE_BUFFER_ENUM(type,id)    ((type)(1000000000 + (1000 * (VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER - 1)) + (id)))
 #define VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID   VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 0)
 
 typedef struct {
@@ -48,7 +47,7 @@
 } VkNativeBufferANDROID;
 
 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_vkAcquireImageANDROID)(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
 typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageANDROID)(VkQueue queue, VkImage image, int* pNativeFenceFd);
 // -- DEPRECATED --
 typedef VkResult (VKAPI_PTR *PFN_vkImportNativeFenceANDROID)(VkDevice device, VkSemaphore semaphore, int nativeFenceFd);
@@ -66,7 +65,8 @@
     VkDevice            device,
     VkImage             image,
     int                 nativeFenceFd,
-    VkSemaphore         semaphore
+    VkSemaphore         semaphore,
+    VkFence             fence
 );
 VKAPI_ATTR VkResult VKAPI_CALL vkQueueSignalReleaseImageANDROID(
     VkQueue             queue,
diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
index fa58c59..014f8e8 100644
--- a/vulkan/include/vulkan/vulkan.h
+++ b/vulkan/include/vulkan/vulkan.h
@@ -41,7 +41,7 @@
     ((major << 22) | (minor << 12) | patch)
 
 // Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 210, 1)
+#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0)
 
 
 #define VK_NULL_HANDLE 0
@@ -107,6 +107,14 @@
 #define VK_MAX_DESCRIPTION_SIZE           256
 
 
+typedef enum VkPipelineCacheHeaderVersion {
+    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
+    VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
+    VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
+    VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1),
+    VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineCacheHeaderVersion;
+
 typedef enum VkResult {
     VK_SUCCESS = 0,
     VK_NOT_READY = 1,
@@ -130,6 +138,7 @@
     VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
     VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
     VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000008000,
+    VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
     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),
@@ -178,18 +187,26 @@
     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
     VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
     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_LOADER_INSTANCE_CREATE_INFO = 46,
-    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 47,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_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_LOADER_INSTANCE_CREATE_INFO = 47,
+    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
     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_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
+    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
+    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
+    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
+    VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
+    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
+    VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000,
     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),
@@ -666,12 +683,11 @@
 } VkFilter;
 
 typedef enum VkSamplerMipmapMode {
-    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_NEAREST = 0,
+    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
+    VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
     VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
-    VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (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_NEAREST + 1),
     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
 } VkSamplerMipmapMode;
 
@@ -846,6 +862,27 @@
 typedef VkFlags VkMemoryHeapFlags;
 typedef VkFlags VkDeviceCreateFlags;
 typedef VkFlags VkDeviceQueueCreateFlags;
+
+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,
+    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
+    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,
+    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
+    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
+    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
+    VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
+    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
+    VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
+    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
+    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
+} VkPipelineStageFlagBits;
+typedef VkFlags VkPipelineStageFlags;
 typedef VkFlags VkMemoryMapFlags;
 
 typedef enum VkImageAspectFlagBits {
@@ -892,7 +929,6 @@
 typedef VkFlags VkQueryPipelineStatisticFlags;
 
 typedef enum VkQueryResultFlagBits {
-    VK_QUERY_RESULT_DEFAULT = 0,
     VK_QUERY_RESULT_64_BIT = 0x00000001,
     VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
     VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
@@ -944,7 +980,7 @@
 } VkShaderStageFlagBits;
 typedef VkFlags VkPipelineVertexInputStateCreateFlags;
 typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
-typedef VkFlags VkPipelineTesselationStateCreateFlags;
+typedef VkFlags VkPipelineTessellationStateCreateFlags;
 typedef VkFlags VkPipelineViewportStateCreateFlags;
 typedef VkFlags VkPipelineRasterizationStateCreateFlags;
 
@@ -986,26 +1022,6 @@
 typedef VkFlags VkAttachmentDescriptionFlags;
 typedef VkFlags VkSubpassDescriptionFlags;
 
-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,
-    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
-    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,
-    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
-    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
-    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
-    VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
-    VK_PIPELINE_STAGE_HOST_BIT = 0x00002000,
-    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00004000,
-    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00008000,
-} VkPipelineStageFlagBits;
-typedef VkFlags VkPipelineStageFlags;
-
 typedef enum VkAccessFlagBits {
     VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
     VK_ACCESS_INDEX_READ_BIT = 0x00000002,
@@ -1061,7 +1077,6 @@
 typedef VkFlags VkCommandBufferResetFlags;
 
 typedef enum VkStencilFaceFlagBits {
-    VK_STENCIL_FACE_NONE = 0,
     VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
     VK_STENCIL_FACE_BACK_BIT = 0x00000002,
     VK_STENCIL_FRONT_AND_BACK = 0x3,
@@ -1114,9 +1129,9 @@
     const void*                                 pNext;
     VkInstanceCreateFlags                       flags;
     const VkApplicationInfo*                    pApplicationInfo;
-    uint32_t                                    enabledLayerNameCount;
+    uint32_t                                    enabledLayerCount;
     const char* const*                          ppEnabledLayerNames;
-    uint32_t                                    enabledExtensionNameCount;
+    uint32_t                                    enabledExtensionCount;
     const char* const*                          ppEnabledExtensionNames;
 } VkInstanceCreateInfo;
 
@@ -1140,6 +1155,7 @@
     VkBool32                                    dualSrcBlend;
     VkBool32                                    logicOp;
     VkBool32                                    multiDrawIndirect;
+    VkBool32                                    drawIndirectFirstInstance;
     VkBool32                                    depthClamp;
     VkBool32                                    depthBiasClamp;
     VkBool32                                    fillModeNonSolid;
@@ -1183,6 +1199,7 @@
     VkBool32                                    sparseResidency16Samples;
     VkBool32                                    sparseResidencyAliased;
     VkBool32                                    variableMultisampleRate;
+    VkBool32                                    inheritedQueries;
 } VkPhysicalDeviceFeatures;
 
 typedef struct VkFormatProperties {
@@ -1192,9 +1209,9 @@
 } VkFormatProperties;
 
 typedef struct VkExtent3D {
-    int32_t                                     width;
-    int32_t                                     height;
-    int32_t                                     depth;
+    uint32_t                                    width;
+    uint32_t                                    height;
+    uint32_t                                    depth;
 } VkExtent3D;
 
 typedef struct VkImageFormatProperties {
@@ -1297,6 +1314,7 @@
     VkSampleCountFlags                          sampledImageStencilSampleCounts;
     VkSampleCountFlags                          storageImageSampleCounts;
     uint32_t                                    maxSampleMaskWords;
+    VkBool32                                    timestampComputeAndGraphics;
     float                                       timestampPeriod;
     uint32_t                                    maxClipDistances;
     uint32_t                                    maxCullDistances;
@@ -1372,9 +1390,9 @@
     VkDeviceCreateFlags                         flags;
     uint32_t                                    queueCreateInfoCount;
     const VkDeviceQueueCreateInfo*              pQueueCreateInfos;
-    uint32_t                                    enabledLayerNameCount;
+    uint32_t                                    enabledLayerCount;
     const char* const*                          ppEnabledLayerNames;
-    uint32_t                                    enabledExtensionNameCount;
+    uint32_t                                    enabledExtensionCount;
     const char* const*                          ppEnabledExtensionNames;
     const VkPhysicalDeviceFeatures*             pEnabledFeatures;
 } VkDeviceCreateInfo;
@@ -1396,6 +1414,7 @@
     const void*                                 pNext;
     uint32_t                                    waitSemaphoreCount;
     const VkSemaphore*                          pWaitSemaphores;
+    const VkPipelineStageFlags*                 pWaitDstStageMask;
     uint32_t                                    commandBufferCount;
     const VkCommandBuffer*                      pCommandBuffers;
     uint32_t                                    signalSemaphoreCount;
@@ -1431,7 +1450,7 @@
 
 typedef struct VkSparseImageMemoryRequirements {
     VkSparseImageFormatProperties               formatProperties;
-    uint32_t                                    imageMipTailStartLod;
+    uint32_t                                    imageMipTailFirstLod;
     VkDeviceSize                                imageMipTailSize;
     VkDeviceSize                                imageMipTailOffset;
     VkDeviceSize                                imageMipTailStride;
@@ -1522,7 +1541,7 @@
     const void*                                 pNext;
     VkQueryPoolCreateFlags                      flags;
     VkQueryType                                 queryType;
-    uint32_t                                    entryCount;
+    uint32_t                                    queryCount;
     VkQueryPipelineStatisticFlags               pipelineStatistics;
 } VkQueryPoolCreateInfo;
 
@@ -1569,6 +1588,7 @@
     VkDeviceSize                                offset;
     VkDeviceSize                                size;
     VkDeviceSize                                rowPitch;
+    VkDeviceSize                                arrayPitch;
     VkDeviceSize                                depthPitch;
 } VkSubresourceLayout;
 
@@ -1671,7 +1691,7 @@
 typedef struct VkPipelineTessellationStateCreateInfo {
     VkStructureType                             sType;
     const void*                                 pNext;
-    VkPipelineTesselationStateCreateFlags       flags;
+    VkPipelineTessellationStateCreateFlags      flags;
     uint32_t                                    patchControlPoints;
 } VkPipelineTessellationStateCreateInfo;
 
@@ -1690,8 +1710,8 @@
 } VkOffset2D;
 
 typedef struct VkExtent2D {
-    int32_t                                     width;
-    int32_t                                     height;
+    uint32_t                                    width;
+    uint32_t                                    height;
 } VkExtent2D;
 
 typedef struct VkRect2D {
@@ -1851,6 +1871,7 @@
     VkSamplerAddressMode                        addressModeV;
     VkSamplerAddressMode                        addressModeW;
     float                                       mipLodBias;
+    VkBool32                                    anisotropyEnable;
     float                                       maxAnisotropy;
     VkBool32                                    compareEnable;
     VkCompareOp                                 compareOp;
@@ -1873,7 +1894,7 @@
     const void*                                 pNext;
     VkDescriptorSetLayoutCreateFlags            flags;
     uint32_t                                    bindingCount;
-    const VkDescriptorSetLayoutBinding*         pBinding;
+    const VkDescriptorSetLayoutBinding*         pBindings;
 } VkDescriptorSetLayoutCreateInfo;
 
 typedef struct VkDescriptorPoolSize {
@@ -1894,7 +1915,7 @@
     VkStructureType                             sType;
     const void*                                 pNext;
     VkDescriptorPool                            descriptorPool;
-    uint32_t                                    setLayoutCount;
+    uint32_t                                    descriptorSetCount;
     const VkDescriptorSetLayout*                pSetLayouts;
 } VkDescriptorSetAllocateInfo;
 
@@ -1974,7 +1995,7 @@
     const VkAttachmentReference*                pResolveAttachments;
     const VkAttachmentReference*                pDepthStencilAttachment;
     uint32_t                                    preserveAttachmentCount;
-    const VkAttachmentReference*                pPreserveAttachments;
+    const uint32_t*                             pPreserveAttachments;
 } VkSubpassDescription;
 
 typedef struct VkSubpassDependency {
@@ -2011,19 +2032,25 @@
     const void*                                 pNext;
     VkCommandPool                               commandPool;
     VkCommandBufferLevel                        level;
-    uint32_t                                    bufferCount;
+    uint32_t                                    commandBufferCount;
 } VkCommandBufferAllocateInfo;
 
-typedef struct VkCommandBufferBeginInfo {
+typedef struct VkCommandBufferInheritanceInfo {
     VkStructureType                             sType;
     const void*                                 pNext;
-    VkCommandBufferUsageFlags                   flags;
     VkRenderPass                                renderPass;
     uint32_t                                    subpass;
     VkFramebuffer                               framebuffer;
     VkBool32                                    occlusionQueryEnable;
     VkQueryControlFlags                         queryFlags;
     VkQueryPipelineStatisticFlags               pipelineStatistics;
+} VkCommandBufferInheritanceInfo;
+
+typedef struct VkCommandBufferBeginInfo {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkCommandBufferUsageFlags                   flags;
+    const VkCommandBufferInheritanceInfo*       pInheritanceInfo;
 } VkCommandBufferBeginInfo;
 
 typedef struct VkBufferCopy {
@@ -2049,11 +2076,9 @@
 
 typedef struct VkImageBlit {
     VkImageSubresourceLayers                    srcSubresource;
-    VkOffset3D                                  srcOffset;
-    VkExtent3D                                  srcExtent;
+    VkOffset3D                                  srcOffsets[2];
     VkImageSubresourceLayers                    dstSubresource;
-    VkOffset3D                                  dstOffset;
-    VkExtent3D                                  dstExtent;
+    VkOffset3D                                  dstOffsets[2];
 } VkImageBlit;
 
 typedef struct VkBufferImageCopy {
@@ -2101,15 +2126,12 @@
     VkExtent3D                                  extent;
 } VkImageResolve;
 
-typedef struct VkRenderPassBeginInfo {
+typedef struct VkMemoryBarrier {
     VkStructureType                             sType;
     const void*                                 pNext;
-    VkRenderPass                                renderPass;
-    VkFramebuffer                               framebuffer;
-    VkRect2D                                    renderArea;
-    uint32_t                                    clearValueCount;
-    const VkClearValue*                         pClearValues;
-} VkRenderPassBeginInfo;
+    VkAccessFlags                               srcAccessMask;
+    VkAccessFlags                               dstAccessMask;
+} VkMemoryBarrier;
 
 typedef struct VkBufferMemoryBarrier {
     VkStructureType                             sType;
@@ -2123,6 +2145,29 @@
     VkDeviceSize                                size;
 } VkBufferMemoryBarrier;
 
+typedef struct VkImageMemoryBarrier {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkAccessFlags                               srcAccessMask;
+    VkAccessFlags                               dstAccessMask;
+    VkImageLayout                               oldLayout;
+    VkImageLayout                               newLayout;
+    uint32_t                                    srcQueueFamilyIndex;
+    uint32_t                                    dstQueueFamilyIndex;
+    VkImage                                     image;
+    VkImageSubresourceRange                     subresourceRange;
+} VkImageMemoryBarrier;
+
+typedef struct VkRenderPassBeginInfo {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkRenderPass                                renderPass;
+    VkFramebuffer                               framebuffer;
+    VkRect2D                                    renderArea;
+    uint32_t                                    clearValueCount;
+    const VkClearValue*                         pClearValues;
+} VkRenderPassBeginInfo;
+
 typedef struct VkDispatchIndirectCommand {
     uint32_t                                    x;
     uint32_t                                    y;
@@ -2144,26 +2189,6 @@
     uint32_t                                    firstInstance;
 } VkDrawIndirectCommand;
 
-typedef struct VkImageMemoryBarrier {
-    VkStructureType                             sType;
-    const void*                                 pNext;
-    VkAccessFlags                               srcAccessMask;
-    VkAccessFlags                               dstAccessMask;
-    VkImageLayout                               oldLayout;
-    VkImageLayout                               newLayout;
-    uint32_t                                    srcQueueFamilyIndex;
-    uint32_t                                    dstQueueFamilyIndex;
-    VkImage                                     image;
-    VkImageSubresourceRange                     subresourceRange;
-} VkImageMemoryBarrier;
-
-typedef struct VkMemoryBarrier {
-    VkStructureType                             sType;
-    const void*                                 pNext;
-    VkAccessFlags                               srcAccessMask;
-    VkAccessFlags                               dstAccessMask;
-} VkMemoryBarrier;
-
 
 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);
@@ -2214,7 +2239,7 @@
 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_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, 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);
@@ -2259,8 +2284,8 @@
 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_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
+typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, 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]);
@@ -2270,7 +2295,7 @@
 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_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, 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);
@@ -2290,18 +2315,18 @@
 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_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
+typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
+typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
+typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, 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* 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);
-typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers);
+typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
 
 #ifdef VK_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
@@ -2562,7 +2587,7 @@
 VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
-    uint32_t                                    startQuery,
+    uint32_t                                    firstQuery,
     uint32_t                                    queryCount,
     size_t                                      dataSize,
     void*                                       pData,
@@ -2813,11 +2838,13 @@
 
 VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
     VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstViewport,
     uint32_t                                    viewportCount,
     const VkViewport*                           pViewports);
 
 VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
     VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstScissor,
     uint32_t                                    scissorCount,
     const VkRect2D*                             pScissors);
 
@@ -2873,7 +2900,7 @@
 
 VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
     VkCommandBuffer                             commandBuffer,
-    uint32_t                                    startBinding,
+    uint32_t                                    firstBinding,
     uint32_t                                    bindingCount,
     const VkBuffer*                             pBuffers,
     const VkDeviceSize*                         pOffsets);
@@ -3023,7 +3050,11 @@
     VkPipelineStageFlags                        srcStageMask,
     VkPipelineStageFlags                        dstStageMask,
     uint32_t                                    memoryBarrierCount,
-    const void* const*                          ppMemoryBarriers);
+    const VkMemoryBarrier*                      pMemoryBarriers,
+    uint32_t                                    bufferMemoryBarrierCount,
+    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
+    uint32_t                                    imageMemoryBarrierCount,
+    const VkImageMemoryBarrier*                 pImageMemoryBarriers);
 
 VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
     VkCommandBuffer                             commandBuffer,
@@ -3031,35 +3062,39 @@
     VkPipelineStageFlags                        dstStageMask,
     VkDependencyFlags                           dependencyFlags,
     uint32_t                                    memoryBarrierCount,
-    const void* const*                          ppMemoryBarriers);
+    const VkMemoryBarrier*                      pMemoryBarriers,
+    uint32_t                                    bufferMemoryBarrierCount,
+    const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
+    uint32_t                                    imageMemoryBarrierCount,
+    const VkImageMemoryBarrier*                 pImageMemoryBarriers);
 
 VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
     VkCommandBuffer                             commandBuffer,
     VkQueryPool                                 queryPool,
-    uint32_t                                    entry,
+    uint32_t                                    query,
     VkQueryControlFlags                         flags);
 
 VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
     VkCommandBuffer                             commandBuffer,
     VkQueryPool                                 queryPool,
-    uint32_t                                    entry);
+    uint32_t                                    query);
 
 VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
     VkCommandBuffer                             commandBuffer,
     VkQueryPool                                 queryPool,
-    uint32_t                                    startQuery,
+    uint32_t                                    firstQuery,
     uint32_t                                    queryCount);
 
 VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
     VkCommandBuffer                             commandBuffer,
     VkPipelineStageFlagBits                     pipelineStage,
     VkQueryPool                                 queryPool,
-    uint32_t                                    entry);
+    uint32_t                                    query);
 
 VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
     VkCommandBuffer                             commandBuffer,
     VkQueryPool                                 queryPool,
-    uint32_t                                    startQuery,
+    uint32_t                                    firstQuery,
     uint32_t                                    queryCount,
     VkBuffer                                    dstBuffer,
     VkDeviceSize                                dstOffset,
@@ -3088,15 +3123,14 @@
 
 VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
     VkCommandBuffer                             commandBuffer,
-    uint32_t                                    commandBuffersCount,
+    uint32_t                                    commandBufferCount,
     const VkCommandBuffer*                      pCommandBuffers);
 #endif
 
 #define VK_KHR_surface 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
 
-#define VK_KHR_SURFACE_REVISION           24
-#define VK_KHR_SURFACE_EXTENSION_NUMBER   1
+#define VK_KHR_SURFACE_SPEC_VERSION       24
 #define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
 
 
@@ -3121,7 +3155,7 @@
 
 
 typedef enum VkSurfaceTransformFlagBitsKHR {
-    VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
+    VK_SURFACE_TRANSFORM_IDENTITY_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,
@@ -3160,7 +3194,7 @@
 } VkSurfaceFormatKHR;
 
 
-typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance  instance, VkSurfaceKHR  surface, const VkAllocationCallbacks* pAllocator);
+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);
@@ -3168,8 +3202,8 @@
 
 #ifdef VK_PROTOTYPES
 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
-    VkInstance                                   instance,
-    VkSurfaceKHR                                 surface,
+    VkInstance                                  instance,
+    VkSurfaceKHR                                surface,
     const VkAllocationCallbacks*                pAllocator);
 
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
@@ -3199,8 +3233,7 @@
 #define VK_KHR_swapchain 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
 
-#define VK_KHR_SWAPCHAIN_REVISION         67
-#define VK_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
+#define VK_KHR_SWAPCHAIN_SPEC_VERSION     67
 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
 
 typedef VkFlags VkSwapchainCreateFlagsKHR;
@@ -3238,49 +3271,48 @@
 } VkPresentInfoKHR;
 
 
-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, const VkPresentInfoKHR*  pPresentInfo);
+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, const VkPresentInfoKHR* pPresentInfo);
 
 #ifdef VK_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
-    VkDevice                                     device,
-    const VkSwapchainCreateInfoKHR*              pCreateInfo,
+    VkDevice                                    device,
+    const VkSwapchainCreateInfoKHR*             pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
-    VkSwapchainKHR*                              pSwapchain);
+    VkSwapchainKHR*                             pSwapchain);
 
 VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
-    VkDevice                                     device,
-    VkSwapchainKHR                               swapchain,
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
     const VkAllocationCallbacks*                pAllocator);
 
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
-    VkDevice                                     device,
-    VkSwapchainKHR                               swapchain,
-    uint32_t*                                    pSwapchainImageCount,
-    VkImage*                                     pSwapchainImages);
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    uint32_t*                                   pSwapchainImageCount,
+    VkImage*                                    pSwapchainImages);
 
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
-    VkDevice                                     device,
-    VkSwapchainKHR                               swapchain,
-    uint64_t                                     timeout,
-    VkSemaphore                                  semaphore,
-    VkFence                                      fence,
-    uint32_t*                                    pImageIndex);
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    uint64_t                                    timeout,
+    VkSemaphore                                 semaphore,
+    VkFence                                     fence,
+    uint32_t*                                   pImageIndex);
 
 VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
-    VkQueue                                      queue,
-    const VkPresentInfoKHR*                      pPresentInfo);
+    VkQueue                                     queue,
+    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           21
-#define VK_KHR_DISPLAY_EXTENSION_NUMBER   3
+#define VK_KHR_DISPLAY_SPEC_VERSION       21
 #define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
 
 
@@ -3354,7 +3386,7 @@
 
 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* pDisplayCount, VkDisplayKHR* pDisplays);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, 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, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
@@ -3373,6 +3405,7 @@
 
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
     VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    planeIndex,
     uint32_t*                                   pDisplayCount,
     VkDisplayKHR*                               pDisplays);
 
@@ -3403,8 +3436,7 @@
 #endif
 
 #define VK_KHR_display_swapchain 1
-#define VK_KHR_DISPLAY_SWAPCHAIN_REVISION 9
-#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NUMBER 4
+#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
 
 typedef struct VkDisplayPresentInfoKHR {
@@ -3431,18 +3463,27 @@
 #define VK_KHR_xlib_surface 1
 #include <X11/Xlib.h>
 
-#define VK_KHR_XLIB_SURFACE_REVISION      5
-#define VK_KHR_XLIB_SURFACE_EXTENSION_NUMBER 5
+#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
 #define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
 
-typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
+
+typedef struct VkXlibSurfaceCreateInfoKHR {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkXlibSurfaceCreateFlagsKHR                 flags;
+    Display*                                    dpy;
+    Window                                      window;
+} VkXlibSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
 
 #ifdef VK_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
     VkInstance                                  instance,
-    Display*                                    dpy,
-    Window                                      window,
+    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 
@@ -3458,18 +3499,27 @@
 #define VK_KHR_xcb_surface 1
 #include <xcb/xcb.h>
 
-#define VK_KHR_XCB_SURFACE_REVISION       5
-#define VK_KHR_XCB_SURFACE_EXTENSION_NUMBER 6
+#define VK_KHR_XCB_SURFACE_SPEC_VERSION   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, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
+
+typedef struct VkXcbSurfaceCreateInfoKHR {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkXcbSurfaceCreateFlagsKHR                  flags;
+    xcb_connection_t*                           connection;
+    xcb_window_t                                window;
+} VkXcbSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, 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
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
     VkInstance                                  instance,
-    xcb_connection_t*                           connection,
-    xcb_window_t                                window,
+    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 
@@ -3485,18 +3535,27 @@
 #define VK_KHR_wayland_surface 1
 #include <wayland-client.h>
 
-#define VK_KHR_WAYLAND_SURFACE_REVISION   4
-#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NUMBER 7
+#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 5
 #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, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
+
+typedef struct VkWaylandSurfaceCreateInfoKHR {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkWaylandSurfaceCreateFlagsKHR              flags;
+    struct wl_display*                          display;
+    struct wl_surface*                          surface;
+} VkWaylandSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
 
 #ifdef VK_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
     VkInstance                                  instance,
-    struct wl_display*                          display,
-    struct wl_surface*                          surface,
+    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 
@@ -3511,18 +3570,27 @@
 #define VK_KHR_mir_surface 1
 #include <mir_toolkit/client_types.h>
 
-#define VK_KHR_MIR_SURFACE_REVISION       4
-#define VK_KHR_MIR_SURFACE_EXTENSION_NUMBER 8
+#define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
 #define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
 
-typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, MirConnection* connection, MirSurface* mirSurface, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkFlags VkMirSurfaceCreateFlagsKHR;
+
+typedef struct VkMirSurfaceCreateInfoKHR {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkMirSurfaceCreateFlagsKHR                  flags;
+    MirConnection*                              connection;
+    MirSurface*                                 mirSurface;
+} VkMirSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
 
 #ifdef VK_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
     VkInstance                                  instance,
-    MirConnection*                              connection,
-    MirSurface*                                 mirSurface,
+    const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 
@@ -3537,16 +3605,25 @@
 #define VK_KHR_android_surface 1
 #include <android/native_window.h>
 
-#define VK_KHR_ANDROID_SURFACE_REVISION   4
-#define VK_KHR_ANDROID_SURFACE_EXTENSION_NUMBER 9
+#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 5
 #define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
 
-typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, ANativeWindow* window, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
+
+typedef struct VkAndroidSurfaceCreateInfoKHR {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkAndroidSurfaceCreateFlagsKHR              flags;
+    ANativeWindow*                              window;
+} VkAndroidSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 
 #ifdef VK_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
     VkInstance                                  instance,
-    ANativeWindow*                              window,
+    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 #endif
@@ -3556,18 +3633,27 @@
 #define VK_KHR_win32_surface 1
 #include <windows.h>
 
-#define VK_KHR_WIN32_SURFACE_REVISION     4
-#define VK_KHR_WIN32_SURFACE_EXTENSION_NUMBER 10
+#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5
 #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
 
-typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, HINSTANCE hinstance, HWND hwnd, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
+
+typedef struct VkWin32SurfaceCreateInfoKHR {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkWin32SurfaceCreateFlagsKHR                flags;
+    HINSTANCE                                   hinstance;
+    HWND                                        hwnd;
+} VkWin32SurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
 
 #ifdef VK_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
     VkInstance                                  instance,
-    HINSTANCE                                   hinstance,
-    HWND                                        hwnd,
+    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
 
diff --git a/vulkan/libvulkan/Android.mk b/vulkan/libvulkan/Android.mk
index 7a2eb64..4241757 100644
--- a/vulkan/libvulkan/Android.mk
+++ b/vulkan/libvulkan/Android.mk
@@ -19,19 +19,20 @@
 LOCAL_CFLAGS := -std=c99 -fvisibility=hidden -fstrict-aliasing
 LOCAL_CFLAGS += -DLOG_TAG=\"vulkan\"
 LOCAL_CFLAGS += -Weverything -Werror -Wno-padded -Wno-undef
-LOCAL_CPPFLAGS := -std=c++1y \
+LOCAL_CPPFLAGS := -std=c++14 \
 	-Wno-c++98-compat-pedantic \
 	-Wno-exit-time-destructors \
 	-Wno-c99-extensions \
-	-Wno-zero-length-array
+	-Wno-zero-length-array \
+	-Wno-global-constructors
 
 LOCAL_C_INCLUDES := \
 	frameworks/native/vulkan/include \
 	system/core/libsync/include
 
 LOCAL_SRC_FILES := \
-	entry.cpp \
-	get_proc_addr.cpp \
+	dispatch_gen.cpp \
+	layers_extensions.cpp \
 	loader.cpp \
 	swapchain.cpp \
 	vulkan_loader_data.cpp
diff --git a/vulkan/libvulkan/dispatch.tmpl b/vulkan/libvulkan/dispatch.tmpl
new file mode 100644
index 0000000..a387d81
--- /dev/null
+++ b/vulkan/libvulkan/dispatch.tmpl
@@ -0,0 +1,589 @@
+{{/*
+ * 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.
+ */}}
+
+{{Include "../api/templates/vulkan_common.tmpl"}}
+{{Global "clang-format" (Strings "clang-format" "-style=file")}}
+{{Macro "DefineGlobals" $}}
+{{$ | Macro "dispatch_gen.h"   | Format (Global "clang-format") | Write "dispatch_gen.h"  }}
+{{$ | Macro "dispatch_gen.cpp" | Format (Global "clang-format") | Write "dispatch_gen.cpp"}}
+
+{{/*
+-------------------------------------------------------------------------------
+  dispatch_gen.h
+-------------------------------------------------------------------------------
+*/}}
+{{define "dispatch_gen.h"}}
+/*
+•* 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.
+•*/
+¶
+#define VK_PROTOTYPES
+#define VK_USE_PLATFORM_ANDROID_KHR
+#include <vulkan/vk_android_native_buffer.h>
+#include <vulkan/vulkan.h>
+¶
+namespace vulkan {
+¶
+struct InstanceDispatchTable {«
+  // clang-format off
+  {{range $f := AllCommands $}}
+    {{if (Macro "IsInstanceDispatched" $f)}}
+      {{Macro "FunctionPtrName" $f}} {{Macro "BaseName" $f}};
+    {{end}}
+  {{end}}
+  // clang-format on
+»};
+¶
+struct DeviceDispatchTable {«
+  // clang-format off
+  {{range $f := AllCommands $}}
+    {{if (Macro "IsDeviceDispatched" $f)}}
+      {{Macro "FunctionPtrName" $f}} {{Macro "BaseName" $f}};
+    {{end}}
+  {{end}}
+  // clang-format on
+»};
+¶
+struct DriverDispatchTable {«
+  // clang-format off
+  {{range $f := AllCommands $}}
+    {{if (Macro "IsInstanceDispatched" $f)}}
+      {{if not (Macro "IsLoaderFunction" $f)}}
+        {{Macro "FunctionPtrName" $f}} {{Macro "BaseName" $f}};
+      {{end}}
+    {{end}}
+  {{end}}
+
+    PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
+
+    {{/* TODO(jessehall): Needed by swapchain code. Figure out a better way of
+         handling this that avoids the special case. Probably should rework
+         things so the driver dispatch table has all driver functions. Probably
+         need separate instance- and device-level copies, fill in all device-
+         dispatched functions in the device-level copies only, and change
+         GetDeviceProcAddr_Bottom to look in the already-loaded driver
+         dispatch table rather than forwarding to the driver's
+         vkGetDeviceProcAddr. */}}
+    PFN_vkCreateImage CreateImage;
+    PFN_vkDestroyImage DestroyImage;
+
+    PFN_vkGetSwapchainGrallocUsageANDROID GetSwapchainGrallocUsageANDROID;
+    PFN_vkAcquireImageANDROID AcquireImageANDROID;
+    PFN_vkQueueSignalReleaseImageANDROID QueueSignalReleaseImageANDROID;
+  // clang-format on
+»};
+¶
+} // namespace vulkan
+¶{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  dispatch_gen.cpp
+-------------------------------------------------------------------------------
+*/}}
+{{define "dispatch_gen.cpp"}}
+/*
+•* 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.
+•*/
+¶
+#include <log/log.h>
+#include <algorithm>
+#include "loader.h"
+¶
+#define UNLIKELY(expr) __builtin_expect((expr), 0)
+¶
+using namespace vulkan;
+¶
+namespace {
+¶
+struct NameProc {
+    const char* name;
+    PFN_vkVoidFunction proc;
+};
+¶
+PFN_vkVoidFunction Lookup(const char* name, const NameProc* begin, const NameProc* end) {
+    const auto& entry = std::lower_bound(
+        begin, end, name,
+        [](const NameProc& e, const char* n) { return strcmp(e.name, n) < 0; });
+    if (entry == end || strcmp(entry->name, name) != 0)
+        return nullptr;
+    return entry->proc;
+}
+¶
+template <size_t N>
+PFN_vkVoidFunction Lookup(const char* name, const NameProc (&procs)[N]) {
+    return Lookup(name, procs, procs + N);
+}
+¶
+const NameProc kLoaderExportProcs[] = {«
+    // clang-format off
+  {{range $f := SortBy (AllCommands $) "FunctionName"}}
+    {{if (Macro "IsFunctionSupported" $f)}}
+      {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>({{$f.Name}})},
+    {{end}}
+  {{end}}
+    // clang-format on
+»};
+¶
+const NameProc kLoaderGlobalProcs[] = {«
+    // clang-format off
+  {{range $f := SortBy (AllCommands $) "FunctionName"}}
+    {{if and (Macro "HasLoaderTopImpl" $f) (eq (Macro "Vtbl" $f) "Global")}}
+      {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§
+        static_cast<{{Macro "FunctionPtrName" $f}}>(§
+          {{Macro "BaseName" $f}}_Top))},
+    {{end}}
+  {{end}}
+    // clang-format on
+»};
+¶
+const NameProc kLoaderTopProcs[] = {«
+    // clang-format off
+  {{range $f := SortBy (AllCommands $) "FunctionName"}}
+    {{if (Macro "HasLoaderTopImpl" $f)}}
+      {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§
+        static_cast<{{Macro "FunctionPtrName" $f}}>(§
+          {{Macro "BaseName" $f}}_Top))},
+    {{end}}
+  {{end}}
+    // clang-format on
+»};
+¶
+const NameProc kLoaderBottomProcs[] = {«
+    // clang-format off
+  {{range $f := SortBy (AllCommands $) "FunctionName"}}
+    {{if (Macro "HasLoaderBottomImpl" $f)}}
+    {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§
+        static_cast<{{Macro "FunctionPtrName" $f}}>(§
+            {{Macro "BaseName" $f}}_Bottom))},
+    {{end}}
+  {{end}}
+    // clang-format on
+»};
+¶
+struct NameOffset {
+    const char* name;
+    size_t offset;
+};
+¶
+ssize_t Lookup(const char* name,
+               const NameOffset* begin,
+               const NameOffset* end) {
+    const auto& entry = std::lower_bound(
+        begin, end, name, [](const NameOffset& e, const char* n) {
+            return strcmp(e.name, n) < 0;
+        });
+    if (entry == end || strcmp(entry->name, name) != 0)
+        return -1;
+    return static_cast<ssize_t>(entry->offset);
+}
+¶
+template <size_t N, class Table>
+PFN_vkVoidFunction Lookup(const char* name,
+                          const NameOffset (&offsets)[N],
+                          const Table& table) {
+    ssize_t offset = Lookup(name, offsets, offsets + N);
+    if (offset < 0)
+        return nullptr;
+    uintptr_t base = reinterpret_cast<uintptr_t>(&table);
+    return *reinterpret_cast<PFN_vkVoidFunction*>(base +
+                                                  static_cast<size_t>(offset));
+}
+¶
+const NameOffset kInstanceDispatchOffsets[] = {«
+  // clang-format off
+  {{range $f := SortBy (AllCommands $) "FunctionName"}}
+    {{if (Macro "IsInstanceDispatched" $f)}}
+      {"{{$f.Name}}", offsetof(InstanceDispatchTable, {{Macro "BaseName" $f}})},
+    {{end}}
+  {{end}}
+  // clang-format on
+»};
+¶
+const NameOffset kDeviceDispatchOffsets[] = {«
+  // clang-format off
+  {{range $f := SortBy (AllCommands $) "FunctionName"}}
+    {{if (Macro "IsDeviceDispatched" $f)}}
+      {"{{$f.Name}}", offsetof(DeviceDispatchTable, {{Macro "BaseName" $f}})},
+    {{end}}
+  {{end}}
+  // clang-format on
+»};
+¶
+} // anonymous namespace
+¶
+namespace vulkan {
+¶
+PFN_vkVoidFunction GetLoaderExportProcAddr(const char* name) {
+    return Lookup(name, kLoaderExportProcs);
+}
+¶
+PFN_vkVoidFunction GetLoaderGlobalProcAddr(const char* name) {
+    return Lookup(name, kLoaderGlobalProcs);
+}
+¶
+PFN_vkVoidFunction GetLoaderTopProcAddr(const char* name) {
+    return Lookup(name, kLoaderTopProcs);
+}
+¶
+PFN_vkVoidFunction GetLoaderBottomProcAddr(const char* name) {
+    return Lookup(name, kLoaderBottomProcs);
+}
+¶
+PFN_vkVoidFunction GetDispatchProcAddr(const InstanceDispatchTable& dispatch,
+                                       const char* name) {
+    return Lookup(name, kInstanceDispatchOffsets, dispatch);
+}
+¶
+PFN_vkVoidFunction GetDispatchProcAddr(const DeviceDispatchTable& dispatch,
+                                       const char* name) {
+    return Lookup(name, kDeviceDispatchOffsets, dispatch);
+}
+¶
+bool LoadInstanceDispatchTable(VkInstance instance,
+                               PFN_vkGetInstanceProcAddr get_proc_addr,
+                               InstanceDispatchTable& dispatch) {«
+    bool success = true;
+    // clang-format off
+  {{range $f := AllCommands $}}
+    {{if (Macro "IsInstanceDispatched" $f)}}
+    dispatch.{{Macro "BaseName" $f}} = §
+        reinterpret_cast<{{Macro "FunctionPtrName" $f}}>(§
+            get_proc_addr(instance, "{{$f.Name}}"));
+    if (UNLIKELY(!dispatch.{{Macro "BaseName" $f}})) {
+        ALOGE("missing instance proc: %s", "{{$f.Name}}");
+        success = false;
+    }
+    {{end}}
+  {{end}}
+    // clang-format on
+    return success;
+»}
+¶
+bool LoadDeviceDispatchTable(VkDevice device,
+                             PFN_vkGetDeviceProcAddr get_proc_addr,
+                             DeviceDispatchTable& dispatch) {«
+    bool success = true;
+    // clang-format off
+  {{range $f := AllCommands $}}
+    {{if (Macro "IsDeviceDispatched" $f)}}
+    dispatch.{{Macro "BaseName" $f}} = §
+        reinterpret_cast<{{Macro "FunctionPtrName" $f}}>(§
+            get_proc_addr(device, "{{$f.Name}}"));
+    if (UNLIKELY(!dispatch.{{Macro "BaseName" $f}})) {
+        ALOGE("missing device proc: %s", "{{$f.Name}}");
+        success = false;
+    }
+    {{end}}
+  {{end}}
+    // clang-format on
+    return success;
+»}
+¶
+bool LoadDriverDispatchTable(VkInstance instance,
+                             PFN_vkGetInstanceProcAddr get_proc_addr,
+                             DriverDispatchTable& dispatch) {«
+    bool success = true;
+    // clang-format off
+  {{range $f := AllCommands $}}
+    {{if (Macro "IsInstanceDispatched" $f)}}
+      {{if not (Macro "IsLoaderFunction" $f)}}
+    dispatch.{{Macro "BaseName" $f}} = §
+        reinterpret_cast<{{Macro "FunctionPtrName" $f}}>(§
+            get_proc_addr(instance, "{{$f.Name}}"));
+    if (UNLIKELY(!dispatch.{{Macro "BaseName" $f}})) {
+        ALOGE("missing driver proc: %s", "{{$f.Name}}");
+        success = false;
+    }
+      {{end}}
+    {{end}}
+  {{end}}
+    dispatch.GetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(get_proc_addr(instance, "vkGetDeviceProcAddr"));
+    if (UNLIKELY(!dispatch.GetDeviceProcAddr)) {
+        ALOGE("missing driver proc: %s", "vkGetDeviceProcAddr");
+        success = false;
+    }
+    dispatch.CreateImage = reinterpret_cast<PFN_vkCreateImage>(get_proc_addr(instance, "vkCreateImage"));
+    if (UNLIKELY(!dispatch.CreateImage)) {
+        ALOGE("missing driver proc: %s", "vkCreateImage");
+        success = false;
+    }
+    dispatch.DestroyImage = reinterpret_cast<PFN_vkDestroyImage>(get_proc_addr(instance, "vkDestroyImage"));
+    if (UNLIKELY(!dispatch.DestroyImage)) {
+        ALOGE("missing driver proc: %s", "vkDestroyImage");
+        success = false;
+    }
+    dispatch.AcquireImageANDROID = reinterpret_cast<PFN_vkAcquireImageANDROID>(get_proc_addr(instance, "vkAcquireImageANDROID"));
+    if (UNLIKELY(!dispatch.AcquireImageANDROID)) {
+        ALOGE("missing driver proc: %s", "vkAcquireImageANDROID");
+        success = false;
+    }
+    dispatch.QueueSignalReleaseImageANDROID = reinterpret_cast<PFN_vkQueueSignalReleaseImageANDROID>(get_proc_addr(instance, "vkQueueSignalReleaseImageANDROID"));
+    if (UNLIKELY(!dispatch.QueueSignalReleaseImageANDROID)) {
+        ALOGE("missing driver proc: %s", "vkQueueSignalReleaseImageANDROID");
+        success = false;
+    }
+    // clang-format on
+    return success;
+»}
+¶
+} // namespace vulkan
+¶
+// clang-format off
+¶
+{{range $f := AllCommands $}}
+  {{if and (not (GetAnnotation $f "pfn")) (Macro "IsExported" $f)}}
+    __attribute__((visibility("default")))
+    VKAPI_ATTR {{Node "Type" $f.Return}} {{$f.Name}}({{Macro "Parameters" $f}}) {
+      {{if not (IsVoid $f.Return.Type)}}return §{{end}}
+      {{Macro "Dispatch" $f}}({{Macro "Arguments" $f}});
+    }
+    ¶
+  {{end}}
+{{end}}
+¶
+// clang-format on
+¶{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  Emit the dispatch lookup for a function based on its first parameter.
+-------------------------------------------------------------------------------
+*/}}
+{{define "Dispatch"}}
+  {{AssertType $ "Function"}}
+
+  {{if (Macro "HasLoaderTopImpl" $)}}
+    {{Macro "BaseName" $}}_Top§
+  {{else}}
+    {{$p0 := index $.CallParameters 0}}
+    GetDispatchTable({{$p0.Name}}).{{Macro "BaseName" $}}§
+  {{end}}
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  Emits a function name without the "vk" prefix.
+-------------------------------------------------------------------------------
+*/}}
+{{define "BaseName"}}
+  {{AssertType $ "Function"}}
+  {{TrimPrefix "vk" $.Name}}
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  Emits a comma-separated list of C parameter names for the given command.
+-------------------------------------------------------------------------------
+*/}}
+{{define "Arguments"}}
+  {{AssertType $ "Function"}}
+
+  {{ForEach $.CallParameters "ParameterName" | JoinWith ", "}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emit "true" for supported functions that undergo table dispatch. Only global
+  functions and functions handled in the loader top without calling into
+  lower layers are not dispatched.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsInstanceDispatched"}}
+  {{AssertType $ "Function"}}
+  {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Instance")}}
+    {{if (ne $.Name "vkGetInstanceProcAddr")}}true{{end}}
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emit "true" for supported functions that can have device-specific dispatch.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsDeviceDispatched"}}
+  {{AssertType $ "Function"}}
+  {{if (Macro "IsFunctionSupported" $)}}
+    {{if eq (Macro "Vtbl" $) "Device"}}
+      {{if ne $.Name "vkGetDeviceProcAddr"}}
+        true
+      {{end}}
+    {{end}}
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emit "true" if a function is core or from a supportable extension.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsFunctionSupported"}}
+  {{AssertType $ "Function"}}
+  {{if not (GetAnnotation $ "pfn")}}
+    {{$ext := GetAnnotation $ "extension"}}
+    {{if not $ext}}true
+    {{else if not (Macro "IsExtensionBlacklisted" $ext)}}true
+    {{end}}
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Decides whether a function should be exported from the Android Vulkan
+  library. Functions in the core API and in loader extensions are exported.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsExported"}}
+  {{AssertType $ "Function"}}
+
+  {{$ext := GetAnnotation $ "extension"}}
+  {{if $ext}}
+    {{Macro "IsLoaderExtension" $ext}}
+  {{else}}
+    true
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Reports whether an extension function is implemented entirely by the loader,
+  and not implemented by drivers.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsLoaderFunction"}}
+  {{AssertType $ "Function"}}
+
+  {{$ext := GetAnnotation $ "extension"}}
+  {{if $ext}}
+    {{Macro "IsLoaderExtension" $ext}}
+  {{end}}
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  Emit "true" if the loader has a top-level implementation for the function
+  that should be called directly rather than dispatching to the first layer.
+-------------------------------------------------------------------------------
+*/}}
+{{define "HasLoaderTopImpl"}}
+  {{AssertType $ "Function"}}
+
+  {{/* Global functions can't be dispatched */}}
+  {{     if and (not (GetAnnotation $ "pfn")) (eq (Macro "Vtbl" $) "Global")}}true
+
+  {{/* G*PA are implemented by reading the dispatch table, not by dispatching
+       through it. */}}
+  {{else if eq $.Name "vkGetInstanceProcAddr"}}true
+  {{else if eq $.Name "vkGetDeviceProcAddr"}}true
+
+  {{/* Loader top needs to initialize dispatch for device-level dispatchable
+       objects */}}
+  {{else if eq $.Name "vkGetDeviceQueue"}}true
+  {{else if eq $.Name "vkAllocateCommandBuffers"}}true
+
+  {{/* vkDestroy for dispatchable objects needs to handle VK_NULL_HANDLE;
+       trying to dispatch through that would crash. */}}
+  {{else if eq $.Name "vkDestroyInstance"}}true
+  {{else if eq $.Name "vkDestroyDevice"}}true
+
+  {{end}}
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  Emit "true" if the loader has a bottom-level implementation for the function
+  which terminates the dispatch chain.
+-------------------------------------------------------------------------------
+*/}}
+{{define "HasLoaderBottomImpl"}}
+  {{AssertType $ "Function"}}
+
+  {{if (Macro "IsFunctionSupported" $)}}
+    {{     if (eq (Macro "Vtbl" $) "Instance")}}true
+    {{else if (Macro "IsLoaderFunction" $)}}true
+    {{else if (eq $.Name "vkCreateInstance")}}true
+    {{else if (eq $.Name "vkGetDeviceProcAddr")}}true
+    {{end}}
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emit "true" if an extension is unsupportable on Android.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsExtensionBlacklisted"}}
+  {{$ext := index $.Arguments 0}}
+  {{     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}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Reports whether an extension is implemented entirely by the loader,
+  so drivers should not enumerate it.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsLoaderExtension"}}
+  {{$ext := index $.Arguments 0}}
+  {{     if eq $ext "VK_KHR_surface"}}true
+  {{else if eq $ext "VK_KHR_swapchain"}}true
+  {{else if eq $ext "VK_KHR_android_surface"}}true
+  {{end}}
+{{end}}
diff --git a/vulkan/libvulkan/dispatch_gen.cpp b/vulkan/libvulkan/dispatch_gen.cpp
new file mode 100644
index 0000000..f11b791
--- /dev/null
+++ b/vulkan/libvulkan/dispatch_gen.cpp
@@ -0,0 +1,2037 @@
+/*
+ * 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.
+ */
+
+#include <log/log.h>
+#include <algorithm>
+#include "loader.h"
+
+#define UNLIKELY(expr) __builtin_expect((expr), 0)
+
+using namespace vulkan;
+
+namespace {
+
+struct NameProc {
+    const char* name;
+    PFN_vkVoidFunction proc;
+};
+
+PFN_vkVoidFunction Lookup(const char* name,
+                          const NameProc* begin,
+                          const NameProc* end) {
+    const auto& entry = std::lower_bound(
+        begin, end, name,
+        [](const NameProc& e, const char* n) { return strcmp(e.name, n) < 0; });
+    if (entry == end || strcmp(entry->name, name) != 0)
+        return nullptr;
+    return entry->proc;
+}
+
+template <size_t N>
+PFN_vkVoidFunction Lookup(const char* name, const NameProc (&procs)[N]) {
+    return Lookup(name, procs, procs + N);
+}
+
+const NameProc kLoaderExportProcs[] = {
+    // clang-format off
+    {"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR)},
+    {"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)},
+    {"vkCmdBeginQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginQuery)},
+    {"vkCmdBeginRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass)},
+    {"vkCmdBindDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets)},
+    {"vkCmdBindIndexBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer)},
+    {"vkCmdBindPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipeline)},
+    {"vkCmdBindVertexBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers)},
+    {"vkCmdBlitImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage)},
+    {"vkCmdClearAttachments", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearAttachments)},
+    {"vkCmdClearColorImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearColorImage)},
+    {"vkCmdClearDepthStencilImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearDepthStencilImage)},
+    {"vkCmdCopyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer)},
+    {"vkCmdCopyBufferToImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage)},
+    {"vkCmdCopyImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage)},
+    {"vkCmdCopyImageToBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer)},
+    {"vkCmdCopyQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyQueryPoolResults)},
+    {"vkCmdDispatch", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatch)},
+    {"vkCmdDispatchIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchIndirect)},
+    {"vkCmdDraw", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDraw)},
+    {"vkCmdDrawIndexed", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexed)},
+    {"vkCmdDrawIndexedIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirect)},
+    {"vkCmdDrawIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirect)},
+    {"vkCmdEndQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndQuery)},
+    {"vkCmdEndRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass)},
+    {"vkCmdExecuteCommands", reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteCommands)},
+    {"vkCmdFillBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdFillBuffer)},
+    {"vkCmdNextSubpass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass)},
+    {"vkCmdPipelineBarrier", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier)},
+    {"vkCmdPushConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants)},
+    {"vkCmdResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent)},
+    {"vkCmdResetQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetQueryPool)},
+    {"vkCmdResolveImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage)},
+    {"vkCmdSetBlendConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetBlendConstants)},
+    {"vkCmdSetDepthBias", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBias)},
+    {"vkCmdSetDepthBounds", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBounds)},
+    {"vkCmdSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent)},
+    {"vkCmdSetLineWidth", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineWidth)},
+    {"vkCmdSetScissor", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissor)},
+    {"vkCmdSetStencilCompareMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilCompareMask)},
+    {"vkCmdSetStencilReference", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilReference)},
+    {"vkCmdSetStencilWriteMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilWriteMask)},
+    {"vkCmdSetViewport", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewport)},
+    {"vkCmdUpdateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdUpdateBuffer)},
+    {"vkCmdWaitEvents", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents)},
+    {"vkCmdWriteTimestamp", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp)},
+    {"vkCreateAndroidSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateAndroidSurfaceKHR)},
+    {"vkCreateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBuffer)},
+    {"vkCreateBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferView)},
+    {"vkCreateCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateCommandPool)},
+    {"vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateComputePipelines)},
+    {"vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorPool)},
+    {"vkCreateDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorSetLayout)},
+    {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDevice)},
+    {"vkCreateEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCreateEvent)},
+    {"vkCreateFence", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFence)},
+    {"vkCreateFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFramebuffer)},
+    {"vkCreateGraphicsPipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateGraphicsPipelines)},
+    {"vkCreateImage", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImage)},
+    {"vkCreateImageView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImageView)},
+    {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(vkCreateInstance)},
+    {"vkCreatePipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineCache)},
+    {"vkCreatePipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineLayout)},
+    {"vkCreateQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateQueryPool)},
+    {"vkCreateRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass)},
+    {"vkCreateSampler", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSampler)},
+    {"vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSemaphore)},
+    {"vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkCreateShaderModule)},
+    {"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR)},
+    {"vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer)},
+    {"vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferView)},
+    {"vkDestroyCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandPool)},
+    {"vkDestroyDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorPool)},
+    {"vkDestroyDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorSetLayout)},
+    {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDevice)},
+    {"vkDestroyEvent", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyEvent)},
+    {"vkDestroyFence", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFence)},
+    {"vkDestroyFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFramebuffer)},
+    {"vkDestroyImage", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImage)},
+    {"vkDestroyImageView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImageView)},
+    {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyInstance)},
+    {"vkDestroyPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipeline)},
+    {"vkDestroyPipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineCache)},
+    {"vkDestroyPipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineLayout)},
+    {"vkDestroyQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyQueryPool)},
+    {"vkDestroyRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyRenderPass)},
+    {"vkDestroySampler", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySampler)},
+    {"vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySemaphore)},
+    {"vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderModule)},
+    {"vkDestroySurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySurfaceKHR)},
+    {"vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR)},
+    {"vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkDeviceWaitIdle)},
+    {"vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkEndCommandBuffer)},
+    {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateDeviceExtensionProperties)},
+    {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateDeviceLayerProperties)},
+    {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateInstanceExtensionProperties)},
+    {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateInstanceLayerProperties)},
+    {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDevices)},
+    {"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)},
+    {"vkGetDeviceMemoryCommitment", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryCommitment)},
+    {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr)},
+    {"vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceQueue)},
+    {"vkGetEventStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetEventStatus)},
+    {"vkGetFenceStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceStatus)},
+    {"vkGetImageMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements)},
+    {"vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements)},
+    {"vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout)},
+    {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetInstanceProcAddr)},
+    {"vkGetPhysicalDeviceFeatures", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFeatures)},
+    {"vkGetPhysicalDeviceFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFormatProperties)},
+    {"vkGetPhysicalDeviceImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceImageFormatProperties)},
+    {"vkGetPhysicalDeviceMemoryProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMemoryProperties)},
+    {"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)},
+    {"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData)},
+    {"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults)},
+    {"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity)},
+    {"vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR)},
+    {"vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges)},
+    {"vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory)},
+    {"vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(vkMergePipelineCaches)},
+    {"vkQueueBindSparse", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparse)},
+    {"vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR)},
+    {"vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit)},
+    {"vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle)},
+    {"vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandBuffer)},
+    {"vkResetCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandPool)},
+    {"vkResetDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetDescriptorPool)},
+    {"vkResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkResetEvent)},
+    {"vkResetFences", reinterpret_cast<PFN_vkVoidFunction>(vkResetFences)},
+    {"vkSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkSetEvent)},
+    {"vkUnmapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory)},
+    {"vkUpdateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSets)},
+    {"vkWaitForFences", reinterpret_cast<PFN_vkVoidFunction>(vkWaitForFences)},
+    // clang-format on
+};
+
+const NameProc kLoaderGlobalProcs[] = {
+    // clang-format off
+    {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateInstance>(CreateInstance_Top))},
+    {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceExtensionProperties>(EnumerateInstanceExtensionProperties_Top))},
+    {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceLayerProperties>(EnumerateInstanceLayerProperties_Top))},
+    // clang-format on
+};
+
+const NameProc kLoaderTopProcs[] = {
+    // clang-format off
+    {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateCommandBuffers>(AllocateCommandBuffers_Top))},
+    {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateInstance>(CreateInstance_Top))},
+    {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyDevice>(DestroyDevice_Top))},
+    {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyInstance>(DestroyInstance_Top))},
+    {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceExtensionProperties>(EnumerateInstanceExtensionProperties_Top))},
+    {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceLayerProperties>(EnumerateInstanceLayerProperties_Top))},
+    {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceProcAddr>(GetDeviceProcAddr_Top))},
+    {"vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceQueue>(GetDeviceQueue_Top))},
+    {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetInstanceProcAddr>(GetInstanceProcAddr_Top))},
+    // clang-format on
+};
+
+const NameProc kLoaderBottomProcs[] = {
+    // clang-format off
+    {"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAcquireNextImageKHR>(AcquireNextImageKHR_Bottom))},
+    {"vkCreateAndroidSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateAndroidSurfaceKHR>(CreateAndroidSurfaceKHR_Bottom))},
+    {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDevice>(CreateDevice_Bottom))},
+    {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateInstance>(CreateInstance_Bottom))},
+    {"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateSwapchainKHR>(CreateSwapchainKHR_Bottom))},
+    {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyInstance>(DestroyInstance_Bottom))},
+    {"vkDestroySurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroySurfaceKHR>(DestroySurfaceKHR_Bottom))},
+    {"vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroySwapchainKHR>(DestroySwapchainKHR_Bottom))},
+    {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceExtensionProperties>(EnumerateDeviceExtensionProperties_Bottom))},
+    {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceLayerProperties>(EnumerateDeviceLayerProperties_Bottom))},
+    {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumeratePhysicalDevices>(EnumeratePhysicalDevices_Bottom))},
+    {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceProcAddr>(GetDeviceProcAddr_Bottom))},
+    {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetInstanceProcAddr>(GetInstanceProcAddr_Bottom))},
+    {"vkGetPhysicalDeviceFeatures", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFeatures>(GetPhysicalDeviceFeatures_Bottom))},
+    {"vkGetPhysicalDeviceFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFormatProperties>(GetPhysicalDeviceFormatProperties_Bottom))},
+    {"vkGetPhysicalDeviceImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(GetPhysicalDeviceImageFormatProperties_Bottom))},
+    {"vkGetPhysicalDeviceMemoryProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(GetPhysicalDeviceMemoryProperties_Bottom))},
+    {"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceProperties>(GetPhysicalDeviceProperties_Bottom))},
+    {"vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(GetPhysicalDeviceQueueFamilyProperties_Bottom))},
+    {"vkGetPhysicalDeviceSparseImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(GetPhysicalDeviceSparseImageFormatProperties_Bottom))},
+    {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(GetPhysicalDeviceSurfaceCapabilitiesKHR_Bottom))},
+    {"vkGetPhysicalDeviceSurfaceFormatsKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(GetPhysicalDeviceSurfaceFormatsKHR_Bottom))},
+    {"vkGetPhysicalDeviceSurfacePresentModesKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(GetPhysicalDeviceSurfacePresentModesKHR_Bottom))},
+    {"vkGetPhysicalDeviceSurfaceSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(GetPhysicalDeviceSurfaceSupportKHR_Bottom))},
+    {"vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetSwapchainImagesKHR>(GetSwapchainImagesKHR_Bottom))},
+    {"vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueuePresentKHR>(QueuePresentKHR_Bottom))},
+    // clang-format on
+};
+
+struct NameOffset {
+    const char* name;
+    size_t offset;
+};
+
+ssize_t Lookup(const char* name,
+               const NameOffset* begin,
+               const NameOffset* end) {
+    const auto& entry = std::lower_bound(
+        begin, end, name, [](const NameOffset& e, const char* n) {
+            return strcmp(e.name, n) < 0;
+        });
+    if (entry == end || strcmp(entry->name, name) != 0)
+        return -1;
+    return static_cast<ssize_t>(entry->offset);
+}
+
+template <size_t N, class Table>
+PFN_vkVoidFunction Lookup(const char* name,
+                          const NameOffset (&offsets)[N],
+                          const Table& table) {
+    ssize_t offset = Lookup(name, offsets, offsets + N);
+    if (offset < 0)
+        return nullptr;
+    uintptr_t base = reinterpret_cast<uintptr_t>(&table);
+    return *reinterpret_cast<PFN_vkVoidFunction*>(base +
+                                                  static_cast<size_t>(offset));
+}
+
+const NameOffset kInstanceDispatchOffsets[] = {
+    // clang-format off
+    {"vkCreateAndroidSurfaceKHR", offsetof(InstanceDispatchTable, CreateAndroidSurfaceKHR)},
+    {"vkCreateDevice", offsetof(InstanceDispatchTable, CreateDevice)},
+    {"vkDestroyInstance", offsetof(InstanceDispatchTable, DestroyInstance)},
+    {"vkDestroySurfaceKHR", offsetof(InstanceDispatchTable, DestroySurfaceKHR)},
+    {"vkEnumerateDeviceExtensionProperties", offsetof(InstanceDispatchTable, EnumerateDeviceExtensionProperties)},
+    {"vkEnumerateDeviceLayerProperties", offsetof(InstanceDispatchTable, EnumerateDeviceLayerProperties)},
+    {"vkEnumeratePhysicalDevices", offsetof(InstanceDispatchTable, EnumeratePhysicalDevices)},
+    {"vkGetPhysicalDeviceFeatures", offsetof(InstanceDispatchTable, GetPhysicalDeviceFeatures)},
+    {"vkGetPhysicalDeviceFormatProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceFormatProperties)},
+    {"vkGetPhysicalDeviceImageFormatProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceImageFormatProperties)},
+    {"vkGetPhysicalDeviceMemoryProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceMemoryProperties)},
+    {"vkGetPhysicalDeviceProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceProperties)},
+    {"vkGetPhysicalDeviceQueueFamilyProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceQueueFamilyProperties)},
+    {"vkGetPhysicalDeviceSparseImageFormatProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceSparseImageFormatProperties)},
+    {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfaceCapabilitiesKHR)},
+    {"vkGetPhysicalDeviceSurfaceFormatsKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfaceFormatsKHR)},
+    {"vkGetPhysicalDeviceSurfacePresentModesKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfacePresentModesKHR)},
+    {"vkGetPhysicalDeviceSurfaceSupportKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfaceSupportKHR)},
+    // clang-format on
+};
+
+const NameOffset kDeviceDispatchOffsets[] = {
+    // clang-format off
+    {"vkAcquireNextImageKHR", offsetof(DeviceDispatchTable, AcquireNextImageKHR)},
+    {"vkAllocateCommandBuffers", offsetof(DeviceDispatchTable, AllocateCommandBuffers)},
+    {"vkAllocateDescriptorSets", offsetof(DeviceDispatchTable, AllocateDescriptorSets)},
+    {"vkAllocateMemory", offsetof(DeviceDispatchTable, AllocateMemory)},
+    {"vkBeginCommandBuffer", offsetof(DeviceDispatchTable, BeginCommandBuffer)},
+    {"vkBindBufferMemory", offsetof(DeviceDispatchTable, BindBufferMemory)},
+    {"vkBindImageMemory", offsetof(DeviceDispatchTable, BindImageMemory)},
+    {"vkCmdBeginQuery", offsetof(DeviceDispatchTable, CmdBeginQuery)},
+    {"vkCmdBeginRenderPass", offsetof(DeviceDispatchTable, CmdBeginRenderPass)},
+    {"vkCmdBindDescriptorSets", offsetof(DeviceDispatchTable, CmdBindDescriptorSets)},
+    {"vkCmdBindIndexBuffer", offsetof(DeviceDispatchTable, CmdBindIndexBuffer)},
+    {"vkCmdBindPipeline", offsetof(DeviceDispatchTable, CmdBindPipeline)},
+    {"vkCmdBindVertexBuffers", offsetof(DeviceDispatchTable, CmdBindVertexBuffers)},
+    {"vkCmdBlitImage", offsetof(DeviceDispatchTable, CmdBlitImage)},
+    {"vkCmdClearAttachments", offsetof(DeviceDispatchTable, CmdClearAttachments)},
+    {"vkCmdClearColorImage", offsetof(DeviceDispatchTable, CmdClearColorImage)},
+    {"vkCmdClearDepthStencilImage", offsetof(DeviceDispatchTable, CmdClearDepthStencilImage)},
+    {"vkCmdCopyBuffer", offsetof(DeviceDispatchTable, CmdCopyBuffer)},
+    {"vkCmdCopyBufferToImage", offsetof(DeviceDispatchTable, CmdCopyBufferToImage)},
+    {"vkCmdCopyImage", offsetof(DeviceDispatchTable, CmdCopyImage)},
+    {"vkCmdCopyImageToBuffer", offsetof(DeviceDispatchTable, CmdCopyImageToBuffer)},
+    {"vkCmdCopyQueryPoolResults", offsetof(DeviceDispatchTable, CmdCopyQueryPoolResults)},
+    {"vkCmdDispatch", offsetof(DeviceDispatchTable, CmdDispatch)},
+    {"vkCmdDispatchIndirect", offsetof(DeviceDispatchTable, CmdDispatchIndirect)},
+    {"vkCmdDraw", offsetof(DeviceDispatchTable, CmdDraw)},
+    {"vkCmdDrawIndexed", offsetof(DeviceDispatchTable, CmdDrawIndexed)},
+    {"vkCmdDrawIndexedIndirect", offsetof(DeviceDispatchTable, CmdDrawIndexedIndirect)},
+    {"vkCmdDrawIndirect", offsetof(DeviceDispatchTable, CmdDrawIndirect)},
+    {"vkCmdEndQuery", offsetof(DeviceDispatchTable, CmdEndQuery)},
+    {"vkCmdEndRenderPass", offsetof(DeviceDispatchTable, CmdEndRenderPass)},
+    {"vkCmdExecuteCommands", offsetof(DeviceDispatchTable, CmdExecuteCommands)},
+    {"vkCmdFillBuffer", offsetof(DeviceDispatchTable, CmdFillBuffer)},
+    {"vkCmdNextSubpass", offsetof(DeviceDispatchTable, CmdNextSubpass)},
+    {"vkCmdPipelineBarrier", offsetof(DeviceDispatchTable, CmdPipelineBarrier)},
+    {"vkCmdPushConstants", offsetof(DeviceDispatchTable, CmdPushConstants)},
+    {"vkCmdResetEvent", offsetof(DeviceDispatchTable, CmdResetEvent)},
+    {"vkCmdResetQueryPool", offsetof(DeviceDispatchTable, CmdResetQueryPool)},
+    {"vkCmdResolveImage", offsetof(DeviceDispatchTable, CmdResolveImage)},
+    {"vkCmdSetBlendConstants", offsetof(DeviceDispatchTable, CmdSetBlendConstants)},
+    {"vkCmdSetDepthBias", offsetof(DeviceDispatchTable, CmdSetDepthBias)},
+    {"vkCmdSetDepthBounds", offsetof(DeviceDispatchTable, CmdSetDepthBounds)},
+    {"vkCmdSetEvent", offsetof(DeviceDispatchTable, CmdSetEvent)},
+    {"vkCmdSetLineWidth", offsetof(DeviceDispatchTable, CmdSetLineWidth)},
+    {"vkCmdSetScissor", offsetof(DeviceDispatchTable, CmdSetScissor)},
+    {"vkCmdSetStencilCompareMask", offsetof(DeviceDispatchTable, CmdSetStencilCompareMask)},
+    {"vkCmdSetStencilReference", offsetof(DeviceDispatchTable, CmdSetStencilReference)},
+    {"vkCmdSetStencilWriteMask", offsetof(DeviceDispatchTable, CmdSetStencilWriteMask)},
+    {"vkCmdSetViewport", offsetof(DeviceDispatchTable, CmdSetViewport)},
+    {"vkCmdUpdateBuffer", offsetof(DeviceDispatchTable, CmdUpdateBuffer)},
+    {"vkCmdWaitEvents", offsetof(DeviceDispatchTable, CmdWaitEvents)},
+    {"vkCmdWriteTimestamp", offsetof(DeviceDispatchTable, CmdWriteTimestamp)},
+    {"vkCreateBuffer", offsetof(DeviceDispatchTable, CreateBuffer)},
+    {"vkCreateBufferView", offsetof(DeviceDispatchTable, CreateBufferView)},
+    {"vkCreateCommandPool", offsetof(DeviceDispatchTable, CreateCommandPool)},
+    {"vkCreateComputePipelines", offsetof(DeviceDispatchTable, CreateComputePipelines)},
+    {"vkCreateDescriptorPool", offsetof(DeviceDispatchTable, CreateDescriptorPool)},
+    {"vkCreateDescriptorSetLayout", offsetof(DeviceDispatchTable, CreateDescriptorSetLayout)},
+    {"vkCreateEvent", offsetof(DeviceDispatchTable, CreateEvent)},
+    {"vkCreateFence", offsetof(DeviceDispatchTable, CreateFence)},
+    {"vkCreateFramebuffer", offsetof(DeviceDispatchTable, CreateFramebuffer)},
+    {"vkCreateGraphicsPipelines", offsetof(DeviceDispatchTable, CreateGraphicsPipelines)},
+    {"vkCreateImage", offsetof(DeviceDispatchTable, CreateImage)},
+    {"vkCreateImageView", offsetof(DeviceDispatchTable, CreateImageView)},
+    {"vkCreatePipelineCache", offsetof(DeviceDispatchTable, CreatePipelineCache)},
+    {"vkCreatePipelineLayout", offsetof(DeviceDispatchTable, CreatePipelineLayout)},
+    {"vkCreateQueryPool", offsetof(DeviceDispatchTable, CreateQueryPool)},
+    {"vkCreateRenderPass", offsetof(DeviceDispatchTable, CreateRenderPass)},
+    {"vkCreateSampler", offsetof(DeviceDispatchTable, CreateSampler)},
+    {"vkCreateSemaphore", offsetof(DeviceDispatchTable, CreateSemaphore)},
+    {"vkCreateShaderModule", offsetof(DeviceDispatchTable, CreateShaderModule)},
+    {"vkCreateSwapchainKHR", offsetof(DeviceDispatchTable, CreateSwapchainKHR)},
+    {"vkDestroyBuffer", offsetof(DeviceDispatchTable, DestroyBuffer)},
+    {"vkDestroyBufferView", offsetof(DeviceDispatchTable, DestroyBufferView)},
+    {"vkDestroyCommandPool", offsetof(DeviceDispatchTable, DestroyCommandPool)},
+    {"vkDestroyDescriptorPool", offsetof(DeviceDispatchTable, DestroyDescriptorPool)},
+    {"vkDestroyDescriptorSetLayout", offsetof(DeviceDispatchTable, DestroyDescriptorSetLayout)},
+    {"vkDestroyDevice", offsetof(DeviceDispatchTable, DestroyDevice)},
+    {"vkDestroyEvent", offsetof(DeviceDispatchTable, DestroyEvent)},
+    {"vkDestroyFence", offsetof(DeviceDispatchTable, DestroyFence)},
+    {"vkDestroyFramebuffer", offsetof(DeviceDispatchTable, DestroyFramebuffer)},
+    {"vkDestroyImage", offsetof(DeviceDispatchTable, DestroyImage)},
+    {"vkDestroyImageView", offsetof(DeviceDispatchTable, DestroyImageView)},
+    {"vkDestroyPipeline", offsetof(DeviceDispatchTable, DestroyPipeline)},
+    {"vkDestroyPipelineCache", offsetof(DeviceDispatchTable, DestroyPipelineCache)},
+    {"vkDestroyPipelineLayout", offsetof(DeviceDispatchTable, DestroyPipelineLayout)},
+    {"vkDestroyQueryPool", offsetof(DeviceDispatchTable, DestroyQueryPool)},
+    {"vkDestroyRenderPass", offsetof(DeviceDispatchTable, DestroyRenderPass)},
+    {"vkDestroySampler", offsetof(DeviceDispatchTable, DestroySampler)},
+    {"vkDestroySemaphore", offsetof(DeviceDispatchTable, DestroySemaphore)},
+    {"vkDestroyShaderModule", offsetof(DeviceDispatchTable, DestroyShaderModule)},
+    {"vkDestroySwapchainKHR", offsetof(DeviceDispatchTable, DestroySwapchainKHR)},
+    {"vkDeviceWaitIdle", offsetof(DeviceDispatchTable, DeviceWaitIdle)},
+    {"vkEndCommandBuffer", offsetof(DeviceDispatchTable, EndCommandBuffer)},
+    {"vkFlushMappedMemoryRanges", offsetof(DeviceDispatchTable, FlushMappedMemoryRanges)},
+    {"vkFreeCommandBuffers", offsetof(DeviceDispatchTable, FreeCommandBuffers)},
+    {"vkFreeDescriptorSets", offsetof(DeviceDispatchTable, FreeDescriptorSets)},
+    {"vkFreeMemory", offsetof(DeviceDispatchTable, FreeMemory)},
+    {"vkGetBufferMemoryRequirements", offsetof(DeviceDispatchTable, GetBufferMemoryRequirements)},
+    {"vkGetDeviceMemoryCommitment", offsetof(DeviceDispatchTable, GetDeviceMemoryCommitment)},
+    {"vkGetDeviceQueue", offsetof(DeviceDispatchTable, GetDeviceQueue)},
+    {"vkGetEventStatus", offsetof(DeviceDispatchTable, GetEventStatus)},
+    {"vkGetFenceStatus", offsetof(DeviceDispatchTable, GetFenceStatus)},
+    {"vkGetImageMemoryRequirements", offsetof(DeviceDispatchTable, GetImageMemoryRequirements)},
+    {"vkGetImageSparseMemoryRequirements", offsetof(DeviceDispatchTable, GetImageSparseMemoryRequirements)},
+    {"vkGetImageSubresourceLayout", offsetof(DeviceDispatchTable, GetImageSubresourceLayout)},
+    {"vkGetPipelineCacheData", offsetof(DeviceDispatchTable, GetPipelineCacheData)},
+    {"vkGetQueryPoolResults", offsetof(DeviceDispatchTable, GetQueryPoolResults)},
+    {"vkGetRenderAreaGranularity", offsetof(DeviceDispatchTable, GetRenderAreaGranularity)},
+    {"vkGetSwapchainImagesKHR", offsetof(DeviceDispatchTable, GetSwapchainImagesKHR)},
+    {"vkInvalidateMappedMemoryRanges", offsetof(DeviceDispatchTable, InvalidateMappedMemoryRanges)},
+    {"vkMapMemory", offsetof(DeviceDispatchTable, MapMemory)},
+    {"vkMergePipelineCaches", offsetof(DeviceDispatchTable, MergePipelineCaches)},
+    {"vkQueueBindSparse", offsetof(DeviceDispatchTable, QueueBindSparse)},
+    {"vkQueuePresentKHR", offsetof(DeviceDispatchTable, QueuePresentKHR)},
+    {"vkQueueSubmit", offsetof(DeviceDispatchTable, QueueSubmit)},
+    {"vkQueueWaitIdle", offsetof(DeviceDispatchTable, QueueWaitIdle)},
+    {"vkResetCommandBuffer", offsetof(DeviceDispatchTable, ResetCommandBuffer)},
+    {"vkResetCommandPool", offsetof(DeviceDispatchTable, ResetCommandPool)},
+    {"vkResetDescriptorPool", offsetof(DeviceDispatchTable, ResetDescriptorPool)},
+    {"vkResetEvent", offsetof(DeviceDispatchTable, ResetEvent)},
+    {"vkResetFences", offsetof(DeviceDispatchTable, ResetFences)},
+    {"vkSetEvent", offsetof(DeviceDispatchTable, SetEvent)},
+    {"vkUnmapMemory", offsetof(DeviceDispatchTable, UnmapMemory)},
+    {"vkUpdateDescriptorSets", offsetof(DeviceDispatchTable, UpdateDescriptorSets)},
+    {"vkWaitForFences", offsetof(DeviceDispatchTable, WaitForFences)},
+    // clang-format on
+};
+
+}  // anonymous namespace
+
+namespace vulkan {
+
+PFN_vkVoidFunction GetLoaderExportProcAddr(const char* name) {
+    return Lookup(name, kLoaderExportProcs);
+}
+
+PFN_vkVoidFunction GetLoaderGlobalProcAddr(const char* name) {
+    return Lookup(name, kLoaderGlobalProcs);
+}
+
+PFN_vkVoidFunction GetLoaderTopProcAddr(const char* name) {
+    return Lookup(name, kLoaderTopProcs);
+}
+
+PFN_vkVoidFunction GetLoaderBottomProcAddr(const char* name) {
+    return Lookup(name, kLoaderBottomProcs);
+}
+
+PFN_vkVoidFunction GetDispatchProcAddr(const InstanceDispatchTable& dispatch,
+                                       const char* name) {
+    return Lookup(name, kInstanceDispatchOffsets, dispatch);
+}
+
+PFN_vkVoidFunction GetDispatchProcAddr(const DeviceDispatchTable& dispatch,
+                                       const char* name) {
+    return Lookup(name, kDeviceDispatchOffsets, dispatch);
+}
+
+bool LoadInstanceDispatchTable(VkInstance instance,
+                               PFN_vkGetInstanceProcAddr get_proc_addr,
+                               InstanceDispatchTable& dispatch) {
+    bool success = true;
+    // clang-format off
+    dispatch.DestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(get_proc_addr(instance, "vkDestroyInstance"));
+    if (UNLIKELY(!dispatch.DestroyInstance)) {
+        ALOGE("missing instance proc: %s", "vkDestroyInstance");
+        success = false;
+    }
+    dispatch.EnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(get_proc_addr(instance, "vkEnumeratePhysicalDevices"));
+    if (UNLIKELY(!dispatch.EnumeratePhysicalDevices)) {
+        ALOGE("missing instance proc: %s", "vkEnumeratePhysicalDevices");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceProperties)) {
+        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceProperties");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceQueueFamilyProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceQueueFamilyProperties)) {
+        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceQueueFamilyProperties");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceMemoryProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceMemoryProperties)) {
+        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceMemoryProperties");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(get_proc_addr(instance, "vkGetPhysicalDeviceFeatures"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceFeatures)) {
+        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceFeatures");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceFormatProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceFormatProperties)) {
+        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceFormatProperties");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceImageFormatProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceImageFormatProperties)) {
+        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceImageFormatProperties");
+        success = false;
+    }
+    dispatch.CreateDevice = reinterpret_cast<PFN_vkCreateDevice>(get_proc_addr(instance, "vkCreateDevice"));
+    if (UNLIKELY(!dispatch.CreateDevice)) {
+        ALOGE("missing instance proc: %s", "vkCreateDevice");
+        success = false;
+    }
+    dispatch.EnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(get_proc_addr(instance, "vkEnumerateDeviceLayerProperties"));
+    if (UNLIKELY(!dispatch.EnumerateDeviceLayerProperties)) {
+        ALOGE("missing instance proc: %s", "vkEnumerateDeviceLayerProperties");
+        success = false;
+    }
+    dispatch.EnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(get_proc_addr(instance, "vkEnumerateDeviceExtensionProperties"));
+    if (UNLIKELY(!dispatch.EnumerateDeviceExtensionProperties)) {
+        ALOGE("missing instance proc: %s", "vkEnumerateDeviceExtensionProperties");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceSparseImageFormatProperties)) {
+        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSparseImageFormatProperties");
+        success = false;
+    }
+    dispatch.DestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(get_proc_addr(instance, "vkDestroySurfaceKHR"));
+    if (UNLIKELY(!dispatch.DestroySurfaceKHR)) {
+        ALOGE("missing instance proc: %s", "vkDestroySurfaceKHR");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfaceSupportKHR)) {
+        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfaceSupportKHR");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR)) {
+        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfaceFormatsKHR)) {
+        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfaceFormatsKHR");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfacePresentModesKHR)) {
+        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfacePresentModesKHR");
+        success = false;
+    }
+    dispatch.CreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(get_proc_addr(instance, "vkCreateAndroidSurfaceKHR"));
+    if (UNLIKELY(!dispatch.CreateAndroidSurfaceKHR)) {
+        ALOGE("missing instance proc: %s", "vkCreateAndroidSurfaceKHR");
+        success = false;
+    }
+    // clang-format on
+    return success;
+}
+
+bool LoadDeviceDispatchTable(VkDevice device,
+                             PFN_vkGetDeviceProcAddr get_proc_addr,
+                             DeviceDispatchTable& dispatch) {
+    bool success = true;
+    // clang-format off
+    dispatch.DestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(get_proc_addr(device, "vkDestroyDevice"));
+    if (UNLIKELY(!dispatch.DestroyDevice)) {
+        ALOGE("missing device proc: %s", "vkDestroyDevice");
+        success = false;
+    }
+    dispatch.GetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(get_proc_addr(device, "vkGetDeviceQueue"));
+    if (UNLIKELY(!dispatch.GetDeviceQueue)) {
+        ALOGE("missing device proc: %s", "vkGetDeviceQueue");
+        success = false;
+    }
+    dispatch.QueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(get_proc_addr(device, "vkQueueSubmit"));
+    if (UNLIKELY(!dispatch.QueueSubmit)) {
+        ALOGE("missing device proc: %s", "vkQueueSubmit");
+        success = false;
+    }
+    dispatch.QueueWaitIdle = reinterpret_cast<PFN_vkQueueWaitIdle>(get_proc_addr(device, "vkQueueWaitIdle"));
+    if (UNLIKELY(!dispatch.QueueWaitIdle)) {
+        ALOGE("missing device proc: %s", "vkQueueWaitIdle");
+        success = false;
+    }
+    dispatch.DeviceWaitIdle = reinterpret_cast<PFN_vkDeviceWaitIdle>(get_proc_addr(device, "vkDeviceWaitIdle"));
+    if (UNLIKELY(!dispatch.DeviceWaitIdle)) {
+        ALOGE("missing device proc: %s", "vkDeviceWaitIdle");
+        success = false;
+    }
+    dispatch.AllocateMemory = reinterpret_cast<PFN_vkAllocateMemory>(get_proc_addr(device, "vkAllocateMemory"));
+    if (UNLIKELY(!dispatch.AllocateMemory)) {
+        ALOGE("missing device proc: %s", "vkAllocateMemory");
+        success = false;
+    }
+    dispatch.FreeMemory = reinterpret_cast<PFN_vkFreeMemory>(get_proc_addr(device, "vkFreeMemory"));
+    if (UNLIKELY(!dispatch.FreeMemory)) {
+        ALOGE("missing device proc: %s", "vkFreeMemory");
+        success = false;
+    }
+    dispatch.MapMemory = reinterpret_cast<PFN_vkMapMemory>(get_proc_addr(device, "vkMapMemory"));
+    if (UNLIKELY(!dispatch.MapMemory)) {
+        ALOGE("missing device proc: %s", "vkMapMemory");
+        success = false;
+    }
+    dispatch.UnmapMemory = reinterpret_cast<PFN_vkUnmapMemory>(get_proc_addr(device, "vkUnmapMemory"));
+    if (UNLIKELY(!dispatch.UnmapMemory)) {
+        ALOGE("missing device proc: %s", "vkUnmapMemory");
+        success = false;
+    }
+    dispatch.FlushMappedMemoryRanges = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(get_proc_addr(device, "vkFlushMappedMemoryRanges"));
+    if (UNLIKELY(!dispatch.FlushMappedMemoryRanges)) {
+        ALOGE("missing device proc: %s", "vkFlushMappedMemoryRanges");
+        success = false;
+    }
+    dispatch.InvalidateMappedMemoryRanges = reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(get_proc_addr(device, "vkInvalidateMappedMemoryRanges"));
+    if (UNLIKELY(!dispatch.InvalidateMappedMemoryRanges)) {
+        ALOGE("missing device proc: %s", "vkInvalidateMappedMemoryRanges");
+        success = false;
+    }
+    dispatch.GetDeviceMemoryCommitment = reinterpret_cast<PFN_vkGetDeviceMemoryCommitment>(get_proc_addr(device, "vkGetDeviceMemoryCommitment"));
+    if (UNLIKELY(!dispatch.GetDeviceMemoryCommitment)) {
+        ALOGE("missing device proc: %s", "vkGetDeviceMemoryCommitment");
+        success = false;
+    }
+    dispatch.GetBufferMemoryRequirements = reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(get_proc_addr(device, "vkGetBufferMemoryRequirements"));
+    if (UNLIKELY(!dispatch.GetBufferMemoryRequirements)) {
+        ALOGE("missing device proc: %s", "vkGetBufferMemoryRequirements");
+        success = false;
+    }
+    dispatch.BindBufferMemory = reinterpret_cast<PFN_vkBindBufferMemory>(get_proc_addr(device, "vkBindBufferMemory"));
+    if (UNLIKELY(!dispatch.BindBufferMemory)) {
+        ALOGE("missing device proc: %s", "vkBindBufferMemory");
+        success = false;
+    }
+    dispatch.GetImageMemoryRequirements = reinterpret_cast<PFN_vkGetImageMemoryRequirements>(get_proc_addr(device, "vkGetImageMemoryRequirements"));
+    if (UNLIKELY(!dispatch.GetImageMemoryRequirements)) {
+        ALOGE("missing device proc: %s", "vkGetImageMemoryRequirements");
+        success = false;
+    }
+    dispatch.BindImageMemory = reinterpret_cast<PFN_vkBindImageMemory>(get_proc_addr(device, "vkBindImageMemory"));
+    if (UNLIKELY(!dispatch.BindImageMemory)) {
+        ALOGE("missing device proc: %s", "vkBindImageMemory");
+        success = false;
+    }
+    dispatch.GetImageSparseMemoryRequirements = reinterpret_cast<PFN_vkGetImageSparseMemoryRequirements>(get_proc_addr(device, "vkGetImageSparseMemoryRequirements"));
+    if (UNLIKELY(!dispatch.GetImageSparseMemoryRequirements)) {
+        ALOGE("missing device proc: %s", "vkGetImageSparseMemoryRequirements");
+        success = false;
+    }
+    dispatch.QueueBindSparse = reinterpret_cast<PFN_vkQueueBindSparse>(get_proc_addr(device, "vkQueueBindSparse"));
+    if (UNLIKELY(!dispatch.QueueBindSparse)) {
+        ALOGE("missing device proc: %s", "vkQueueBindSparse");
+        success = false;
+    }
+    dispatch.CreateFence = reinterpret_cast<PFN_vkCreateFence>(get_proc_addr(device, "vkCreateFence"));
+    if (UNLIKELY(!dispatch.CreateFence)) {
+        ALOGE("missing device proc: %s", "vkCreateFence");
+        success = false;
+    }
+    dispatch.DestroyFence = reinterpret_cast<PFN_vkDestroyFence>(get_proc_addr(device, "vkDestroyFence"));
+    if (UNLIKELY(!dispatch.DestroyFence)) {
+        ALOGE("missing device proc: %s", "vkDestroyFence");
+        success = false;
+    }
+    dispatch.ResetFences = reinterpret_cast<PFN_vkResetFences>(get_proc_addr(device, "vkResetFences"));
+    if (UNLIKELY(!dispatch.ResetFences)) {
+        ALOGE("missing device proc: %s", "vkResetFences");
+        success = false;
+    }
+    dispatch.GetFenceStatus = reinterpret_cast<PFN_vkGetFenceStatus>(get_proc_addr(device, "vkGetFenceStatus"));
+    if (UNLIKELY(!dispatch.GetFenceStatus)) {
+        ALOGE("missing device proc: %s", "vkGetFenceStatus");
+        success = false;
+    }
+    dispatch.WaitForFences = reinterpret_cast<PFN_vkWaitForFences>(get_proc_addr(device, "vkWaitForFences"));
+    if (UNLIKELY(!dispatch.WaitForFences)) {
+        ALOGE("missing device proc: %s", "vkWaitForFences");
+        success = false;
+    }
+    dispatch.CreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(get_proc_addr(device, "vkCreateSemaphore"));
+    if (UNLIKELY(!dispatch.CreateSemaphore)) {
+        ALOGE("missing device proc: %s", "vkCreateSemaphore");
+        success = false;
+    }
+    dispatch.DestroySemaphore = reinterpret_cast<PFN_vkDestroySemaphore>(get_proc_addr(device, "vkDestroySemaphore"));
+    if (UNLIKELY(!dispatch.DestroySemaphore)) {
+        ALOGE("missing device proc: %s", "vkDestroySemaphore");
+        success = false;
+    }
+    dispatch.CreateEvent = reinterpret_cast<PFN_vkCreateEvent>(get_proc_addr(device, "vkCreateEvent"));
+    if (UNLIKELY(!dispatch.CreateEvent)) {
+        ALOGE("missing device proc: %s", "vkCreateEvent");
+        success = false;
+    }
+    dispatch.DestroyEvent = reinterpret_cast<PFN_vkDestroyEvent>(get_proc_addr(device, "vkDestroyEvent"));
+    if (UNLIKELY(!dispatch.DestroyEvent)) {
+        ALOGE("missing device proc: %s", "vkDestroyEvent");
+        success = false;
+    }
+    dispatch.GetEventStatus = reinterpret_cast<PFN_vkGetEventStatus>(get_proc_addr(device, "vkGetEventStatus"));
+    if (UNLIKELY(!dispatch.GetEventStatus)) {
+        ALOGE("missing device proc: %s", "vkGetEventStatus");
+        success = false;
+    }
+    dispatch.SetEvent = reinterpret_cast<PFN_vkSetEvent>(get_proc_addr(device, "vkSetEvent"));
+    if (UNLIKELY(!dispatch.SetEvent)) {
+        ALOGE("missing device proc: %s", "vkSetEvent");
+        success = false;
+    }
+    dispatch.ResetEvent = reinterpret_cast<PFN_vkResetEvent>(get_proc_addr(device, "vkResetEvent"));
+    if (UNLIKELY(!dispatch.ResetEvent)) {
+        ALOGE("missing device proc: %s", "vkResetEvent");
+        success = false;
+    }
+    dispatch.CreateQueryPool = reinterpret_cast<PFN_vkCreateQueryPool>(get_proc_addr(device, "vkCreateQueryPool"));
+    if (UNLIKELY(!dispatch.CreateQueryPool)) {
+        ALOGE("missing device proc: %s", "vkCreateQueryPool");
+        success = false;
+    }
+    dispatch.DestroyQueryPool = reinterpret_cast<PFN_vkDestroyQueryPool>(get_proc_addr(device, "vkDestroyQueryPool"));
+    if (UNLIKELY(!dispatch.DestroyQueryPool)) {
+        ALOGE("missing device proc: %s", "vkDestroyQueryPool");
+        success = false;
+    }
+    dispatch.GetQueryPoolResults = reinterpret_cast<PFN_vkGetQueryPoolResults>(get_proc_addr(device, "vkGetQueryPoolResults"));
+    if (UNLIKELY(!dispatch.GetQueryPoolResults)) {
+        ALOGE("missing device proc: %s", "vkGetQueryPoolResults");
+        success = false;
+    }
+    dispatch.CreateBuffer = reinterpret_cast<PFN_vkCreateBuffer>(get_proc_addr(device, "vkCreateBuffer"));
+    if (UNLIKELY(!dispatch.CreateBuffer)) {
+        ALOGE("missing device proc: %s", "vkCreateBuffer");
+        success = false;
+    }
+    dispatch.DestroyBuffer = reinterpret_cast<PFN_vkDestroyBuffer>(get_proc_addr(device, "vkDestroyBuffer"));
+    if (UNLIKELY(!dispatch.DestroyBuffer)) {
+        ALOGE("missing device proc: %s", "vkDestroyBuffer");
+        success = false;
+    }
+    dispatch.CreateBufferView = reinterpret_cast<PFN_vkCreateBufferView>(get_proc_addr(device, "vkCreateBufferView"));
+    if (UNLIKELY(!dispatch.CreateBufferView)) {
+        ALOGE("missing device proc: %s", "vkCreateBufferView");
+        success = false;
+    }
+    dispatch.DestroyBufferView = reinterpret_cast<PFN_vkDestroyBufferView>(get_proc_addr(device, "vkDestroyBufferView"));
+    if (UNLIKELY(!dispatch.DestroyBufferView)) {
+        ALOGE("missing device proc: %s", "vkDestroyBufferView");
+        success = false;
+    }
+    dispatch.CreateImage = reinterpret_cast<PFN_vkCreateImage>(get_proc_addr(device, "vkCreateImage"));
+    if (UNLIKELY(!dispatch.CreateImage)) {
+        ALOGE("missing device proc: %s", "vkCreateImage");
+        success = false;
+    }
+    dispatch.DestroyImage = reinterpret_cast<PFN_vkDestroyImage>(get_proc_addr(device, "vkDestroyImage"));
+    if (UNLIKELY(!dispatch.DestroyImage)) {
+        ALOGE("missing device proc: %s", "vkDestroyImage");
+        success = false;
+    }
+    dispatch.GetImageSubresourceLayout = reinterpret_cast<PFN_vkGetImageSubresourceLayout>(get_proc_addr(device, "vkGetImageSubresourceLayout"));
+    if (UNLIKELY(!dispatch.GetImageSubresourceLayout)) {
+        ALOGE("missing device proc: %s", "vkGetImageSubresourceLayout");
+        success = false;
+    }
+    dispatch.CreateImageView = reinterpret_cast<PFN_vkCreateImageView>(get_proc_addr(device, "vkCreateImageView"));
+    if (UNLIKELY(!dispatch.CreateImageView)) {
+        ALOGE("missing device proc: %s", "vkCreateImageView");
+        success = false;
+    }
+    dispatch.DestroyImageView = reinterpret_cast<PFN_vkDestroyImageView>(get_proc_addr(device, "vkDestroyImageView"));
+    if (UNLIKELY(!dispatch.DestroyImageView)) {
+        ALOGE("missing device proc: %s", "vkDestroyImageView");
+        success = false;
+    }
+    dispatch.CreateShaderModule = reinterpret_cast<PFN_vkCreateShaderModule>(get_proc_addr(device, "vkCreateShaderModule"));
+    if (UNLIKELY(!dispatch.CreateShaderModule)) {
+        ALOGE("missing device proc: %s", "vkCreateShaderModule");
+        success = false;
+    }
+    dispatch.DestroyShaderModule = reinterpret_cast<PFN_vkDestroyShaderModule>(get_proc_addr(device, "vkDestroyShaderModule"));
+    if (UNLIKELY(!dispatch.DestroyShaderModule)) {
+        ALOGE("missing device proc: %s", "vkDestroyShaderModule");
+        success = false;
+    }
+    dispatch.CreatePipelineCache = reinterpret_cast<PFN_vkCreatePipelineCache>(get_proc_addr(device, "vkCreatePipelineCache"));
+    if (UNLIKELY(!dispatch.CreatePipelineCache)) {
+        ALOGE("missing device proc: %s", "vkCreatePipelineCache");
+        success = false;
+    }
+    dispatch.DestroyPipelineCache = reinterpret_cast<PFN_vkDestroyPipelineCache>(get_proc_addr(device, "vkDestroyPipelineCache"));
+    if (UNLIKELY(!dispatch.DestroyPipelineCache)) {
+        ALOGE("missing device proc: %s", "vkDestroyPipelineCache");
+        success = false;
+    }
+    dispatch.GetPipelineCacheData = reinterpret_cast<PFN_vkGetPipelineCacheData>(get_proc_addr(device, "vkGetPipelineCacheData"));
+    if (UNLIKELY(!dispatch.GetPipelineCacheData)) {
+        ALOGE("missing device proc: %s", "vkGetPipelineCacheData");
+        success = false;
+    }
+    dispatch.MergePipelineCaches = reinterpret_cast<PFN_vkMergePipelineCaches>(get_proc_addr(device, "vkMergePipelineCaches"));
+    if (UNLIKELY(!dispatch.MergePipelineCaches)) {
+        ALOGE("missing device proc: %s", "vkMergePipelineCaches");
+        success = false;
+    }
+    dispatch.CreateGraphicsPipelines = reinterpret_cast<PFN_vkCreateGraphicsPipelines>(get_proc_addr(device, "vkCreateGraphicsPipelines"));
+    if (UNLIKELY(!dispatch.CreateGraphicsPipelines)) {
+        ALOGE("missing device proc: %s", "vkCreateGraphicsPipelines");
+        success = false;
+    }
+    dispatch.CreateComputePipelines = reinterpret_cast<PFN_vkCreateComputePipelines>(get_proc_addr(device, "vkCreateComputePipelines"));
+    if (UNLIKELY(!dispatch.CreateComputePipelines)) {
+        ALOGE("missing device proc: %s", "vkCreateComputePipelines");
+        success = false;
+    }
+    dispatch.DestroyPipeline = reinterpret_cast<PFN_vkDestroyPipeline>(get_proc_addr(device, "vkDestroyPipeline"));
+    if (UNLIKELY(!dispatch.DestroyPipeline)) {
+        ALOGE("missing device proc: %s", "vkDestroyPipeline");
+        success = false;
+    }
+    dispatch.CreatePipelineLayout = reinterpret_cast<PFN_vkCreatePipelineLayout>(get_proc_addr(device, "vkCreatePipelineLayout"));
+    if (UNLIKELY(!dispatch.CreatePipelineLayout)) {
+        ALOGE("missing device proc: %s", "vkCreatePipelineLayout");
+        success = false;
+    }
+    dispatch.DestroyPipelineLayout = reinterpret_cast<PFN_vkDestroyPipelineLayout>(get_proc_addr(device, "vkDestroyPipelineLayout"));
+    if (UNLIKELY(!dispatch.DestroyPipelineLayout)) {
+        ALOGE("missing device proc: %s", "vkDestroyPipelineLayout");
+        success = false;
+    }
+    dispatch.CreateSampler = reinterpret_cast<PFN_vkCreateSampler>(get_proc_addr(device, "vkCreateSampler"));
+    if (UNLIKELY(!dispatch.CreateSampler)) {
+        ALOGE("missing device proc: %s", "vkCreateSampler");
+        success = false;
+    }
+    dispatch.DestroySampler = reinterpret_cast<PFN_vkDestroySampler>(get_proc_addr(device, "vkDestroySampler"));
+    if (UNLIKELY(!dispatch.DestroySampler)) {
+        ALOGE("missing device proc: %s", "vkDestroySampler");
+        success = false;
+    }
+    dispatch.CreateDescriptorSetLayout = reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(get_proc_addr(device, "vkCreateDescriptorSetLayout"));
+    if (UNLIKELY(!dispatch.CreateDescriptorSetLayout)) {
+        ALOGE("missing device proc: %s", "vkCreateDescriptorSetLayout");
+        success = false;
+    }
+    dispatch.DestroyDescriptorSetLayout = reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(get_proc_addr(device, "vkDestroyDescriptorSetLayout"));
+    if (UNLIKELY(!dispatch.DestroyDescriptorSetLayout)) {
+        ALOGE("missing device proc: %s", "vkDestroyDescriptorSetLayout");
+        success = false;
+    }
+    dispatch.CreateDescriptorPool = reinterpret_cast<PFN_vkCreateDescriptorPool>(get_proc_addr(device, "vkCreateDescriptorPool"));
+    if (UNLIKELY(!dispatch.CreateDescriptorPool)) {
+        ALOGE("missing device proc: %s", "vkCreateDescriptorPool");
+        success = false;
+    }
+    dispatch.DestroyDescriptorPool = reinterpret_cast<PFN_vkDestroyDescriptorPool>(get_proc_addr(device, "vkDestroyDescriptorPool"));
+    if (UNLIKELY(!dispatch.DestroyDescriptorPool)) {
+        ALOGE("missing device proc: %s", "vkDestroyDescriptorPool");
+        success = false;
+    }
+    dispatch.ResetDescriptorPool = reinterpret_cast<PFN_vkResetDescriptorPool>(get_proc_addr(device, "vkResetDescriptorPool"));
+    if (UNLIKELY(!dispatch.ResetDescriptorPool)) {
+        ALOGE("missing device proc: %s", "vkResetDescriptorPool");
+        success = false;
+    }
+    dispatch.AllocateDescriptorSets = reinterpret_cast<PFN_vkAllocateDescriptorSets>(get_proc_addr(device, "vkAllocateDescriptorSets"));
+    if (UNLIKELY(!dispatch.AllocateDescriptorSets)) {
+        ALOGE("missing device proc: %s", "vkAllocateDescriptorSets");
+        success = false;
+    }
+    dispatch.FreeDescriptorSets = reinterpret_cast<PFN_vkFreeDescriptorSets>(get_proc_addr(device, "vkFreeDescriptorSets"));
+    if (UNLIKELY(!dispatch.FreeDescriptorSets)) {
+        ALOGE("missing device proc: %s", "vkFreeDescriptorSets");
+        success = false;
+    }
+    dispatch.UpdateDescriptorSets = reinterpret_cast<PFN_vkUpdateDescriptorSets>(get_proc_addr(device, "vkUpdateDescriptorSets"));
+    if (UNLIKELY(!dispatch.UpdateDescriptorSets)) {
+        ALOGE("missing device proc: %s", "vkUpdateDescriptorSets");
+        success = false;
+    }
+    dispatch.CreateFramebuffer = reinterpret_cast<PFN_vkCreateFramebuffer>(get_proc_addr(device, "vkCreateFramebuffer"));
+    if (UNLIKELY(!dispatch.CreateFramebuffer)) {
+        ALOGE("missing device proc: %s", "vkCreateFramebuffer");
+        success = false;
+    }
+    dispatch.DestroyFramebuffer = reinterpret_cast<PFN_vkDestroyFramebuffer>(get_proc_addr(device, "vkDestroyFramebuffer"));
+    if (UNLIKELY(!dispatch.DestroyFramebuffer)) {
+        ALOGE("missing device proc: %s", "vkDestroyFramebuffer");
+        success = false;
+    }
+    dispatch.CreateRenderPass = reinterpret_cast<PFN_vkCreateRenderPass>(get_proc_addr(device, "vkCreateRenderPass"));
+    if (UNLIKELY(!dispatch.CreateRenderPass)) {
+        ALOGE("missing device proc: %s", "vkCreateRenderPass");
+        success = false;
+    }
+    dispatch.DestroyRenderPass = reinterpret_cast<PFN_vkDestroyRenderPass>(get_proc_addr(device, "vkDestroyRenderPass"));
+    if (UNLIKELY(!dispatch.DestroyRenderPass)) {
+        ALOGE("missing device proc: %s", "vkDestroyRenderPass");
+        success = false;
+    }
+    dispatch.GetRenderAreaGranularity = reinterpret_cast<PFN_vkGetRenderAreaGranularity>(get_proc_addr(device, "vkGetRenderAreaGranularity"));
+    if (UNLIKELY(!dispatch.GetRenderAreaGranularity)) {
+        ALOGE("missing device proc: %s", "vkGetRenderAreaGranularity");
+        success = false;
+    }
+    dispatch.CreateCommandPool = reinterpret_cast<PFN_vkCreateCommandPool>(get_proc_addr(device, "vkCreateCommandPool"));
+    if (UNLIKELY(!dispatch.CreateCommandPool)) {
+        ALOGE("missing device proc: %s", "vkCreateCommandPool");
+        success = false;
+    }
+    dispatch.DestroyCommandPool = reinterpret_cast<PFN_vkDestroyCommandPool>(get_proc_addr(device, "vkDestroyCommandPool"));
+    if (UNLIKELY(!dispatch.DestroyCommandPool)) {
+        ALOGE("missing device proc: %s", "vkDestroyCommandPool");
+        success = false;
+    }
+    dispatch.ResetCommandPool = reinterpret_cast<PFN_vkResetCommandPool>(get_proc_addr(device, "vkResetCommandPool"));
+    if (UNLIKELY(!dispatch.ResetCommandPool)) {
+        ALOGE("missing device proc: %s", "vkResetCommandPool");
+        success = false;
+    }
+    dispatch.AllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(get_proc_addr(device, "vkAllocateCommandBuffers"));
+    if (UNLIKELY(!dispatch.AllocateCommandBuffers)) {
+        ALOGE("missing device proc: %s", "vkAllocateCommandBuffers");
+        success = false;
+    }
+    dispatch.FreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(get_proc_addr(device, "vkFreeCommandBuffers"));
+    if (UNLIKELY(!dispatch.FreeCommandBuffers)) {
+        ALOGE("missing device proc: %s", "vkFreeCommandBuffers");
+        success = false;
+    }
+    dispatch.BeginCommandBuffer = reinterpret_cast<PFN_vkBeginCommandBuffer>(get_proc_addr(device, "vkBeginCommandBuffer"));
+    if (UNLIKELY(!dispatch.BeginCommandBuffer)) {
+        ALOGE("missing device proc: %s", "vkBeginCommandBuffer");
+        success = false;
+    }
+    dispatch.EndCommandBuffer = reinterpret_cast<PFN_vkEndCommandBuffer>(get_proc_addr(device, "vkEndCommandBuffer"));
+    if (UNLIKELY(!dispatch.EndCommandBuffer)) {
+        ALOGE("missing device proc: %s", "vkEndCommandBuffer");
+        success = false;
+    }
+    dispatch.ResetCommandBuffer = reinterpret_cast<PFN_vkResetCommandBuffer>(get_proc_addr(device, "vkResetCommandBuffer"));
+    if (UNLIKELY(!dispatch.ResetCommandBuffer)) {
+        ALOGE("missing device proc: %s", "vkResetCommandBuffer");
+        success = false;
+    }
+    dispatch.CmdBindPipeline = reinterpret_cast<PFN_vkCmdBindPipeline>(get_proc_addr(device, "vkCmdBindPipeline"));
+    if (UNLIKELY(!dispatch.CmdBindPipeline)) {
+        ALOGE("missing device proc: %s", "vkCmdBindPipeline");
+        success = false;
+    }
+    dispatch.CmdSetViewport = reinterpret_cast<PFN_vkCmdSetViewport>(get_proc_addr(device, "vkCmdSetViewport"));
+    if (UNLIKELY(!dispatch.CmdSetViewport)) {
+        ALOGE("missing device proc: %s", "vkCmdSetViewport");
+        success = false;
+    }
+    dispatch.CmdSetScissor = reinterpret_cast<PFN_vkCmdSetScissor>(get_proc_addr(device, "vkCmdSetScissor"));
+    if (UNLIKELY(!dispatch.CmdSetScissor)) {
+        ALOGE("missing device proc: %s", "vkCmdSetScissor");
+        success = false;
+    }
+    dispatch.CmdSetLineWidth = reinterpret_cast<PFN_vkCmdSetLineWidth>(get_proc_addr(device, "vkCmdSetLineWidth"));
+    if (UNLIKELY(!dispatch.CmdSetLineWidth)) {
+        ALOGE("missing device proc: %s", "vkCmdSetLineWidth");
+        success = false;
+    }
+    dispatch.CmdSetDepthBias = reinterpret_cast<PFN_vkCmdSetDepthBias>(get_proc_addr(device, "vkCmdSetDepthBias"));
+    if (UNLIKELY(!dispatch.CmdSetDepthBias)) {
+        ALOGE("missing device proc: %s", "vkCmdSetDepthBias");
+        success = false;
+    }
+    dispatch.CmdSetBlendConstants = reinterpret_cast<PFN_vkCmdSetBlendConstants>(get_proc_addr(device, "vkCmdSetBlendConstants"));
+    if (UNLIKELY(!dispatch.CmdSetBlendConstants)) {
+        ALOGE("missing device proc: %s", "vkCmdSetBlendConstants");
+        success = false;
+    }
+    dispatch.CmdSetDepthBounds = reinterpret_cast<PFN_vkCmdSetDepthBounds>(get_proc_addr(device, "vkCmdSetDepthBounds"));
+    if (UNLIKELY(!dispatch.CmdSetDepthBounds)) {
+        ALOGE("missing device proc: %s", "vkCmdSetDepthBounds");
+        success = false;
+    }
+    dispatch.CmdSetStencilCompareMask = reinterpret_cast<PFN_vkCmdSetStencilCompareMask>(get_proc_addr(device, "vkCmdSetStencilCompareMask"));
+    if (UNLIKELY(!dispatch.CmdSetStencilCompareMask)) {
+        ALOGE("missing device proc: %s", "vkCmdSetStencilCompareMask");
+        success = false;
+    }
+    dispatch.CmdSetStencilWriteMask = reinterpret_cast<PFN_vkCmdSetStencilWriteMask>(get_proc_addr(device, "vkCmdSetStencilWriteMask"));
+    if (UNLIKELY(!dispatch.CmdSetStencilWriteMask)) {
+        ALOGE("missing device proc: %s", "vkCmdSetStencilWriteMask");
+        success = false;
+    }
+    dispatch.CmdSetStencilReference = reinterpret_cast<PFN_vkCmdSetStencilReference>(get_proc_addr(device, "vkCmdSetStencilReference"));
+    if (UNLIKELY(!dispatch.CmdSetStencilReference)) {
+        ALOGE("missing device proc: %s", "vkCmdSetStencilReference");
+        success = false;
+    }
+    dispatch.CmdBindDescriptorSets = reinterpret_cast<PFN_vkCmdBindDescriptorSets>(get_proc_addr(device, "vkCmdBindDescriptorSets"));
+    if (UNLIKELY(!dispatch.CmdBindDescriptorSets)) {
+        ALOGE("missing device proc: %s", "vkCmdBindDescriptorSets");
+        success = false;
+    }
+    dispatch.CmdBindIndexBuffer = reinterpret_cast<PFN_vkCmdBindIndexBuffer>(get_proc_addr(device, "vkCmdBindIndexBuffer"));
+    if (UNLIKELY(!dispatch.CmdBindIndexBuffer)) {
+        ALOGE("missing device proc: %s", "vkCmdBindIndexBuffer");
+        success = false;
+    }
+    dispatch.CmdBindVertexBuffers = reinterpret_cast<PFN_vkCmdBindVertexBuffers>(get_proc_addr(device, "vkCmdBindVertexBuffers"));
+    if (UNLIKELY(!dispatch.CmdBindVertexBuffers)) {
+        ALOGE("missing device proc: %s", "vkCmdBindVertexBuffers");
+        success = false;
+    }
+    dispatch.CmdDraw = reinterpret_cast<PFN_vkCmdDraw>(get_proc_addr(device, "vkCmdDraw"));
+    if (UNLIKELY(!dispatch.CmdDraw)) {
+        ALOGE("missing device proc: %s", "vkCmdDraw");
+        success = false;
+    }
+    dispatch.CmdDrawIndexed = reinterpret_cast<PFN_vkCmdDrawIndexed>(get_proc_addr(device, "vkCmdDrawIndexed"));
+    if (UNLIKELY(!dispatch.CmdDrawIndexed)) {
+        ALOGE("missing device proc: %s", "vkCmdDrawIndexed");
+        success = false;
+    }
+    dispatch.CmdDrawIndirect = reinterpret_cast<PFN_vkCmdDrawIndirect>(get_proc_addr(device, "vkCmdDrawIndirect"));
+    if (UNLIKELY(!dispatch.CmdDrawIndirect)) {
+        ALOGE("missing device proc: %s", "vkCmdDrawIndirect");
+        success = false;
+    }
+    dispatch.CmdDrawIndexedIndirect = reinterpret_cast<PFN_vkCmdDrawIndexedIndirect>(get_proc_addr(device, "vkCmdDrawIndexedIndirect"));
+    if (UNLIKELY(!dispatch.CmdDrawIndexedIndirect)) {
+        ALOGE("missing device proc: %s", "vkCmdDrawIndexedIndirect");
+        success = false;
+    }
+    dispatch.CmdDispatch = reinterpret_cast<PFN_vkCmdDispatch>(get_proc_addr(device, "vkCmdDispatch"));
+    if (UNLIKELY(!dispatch.CmdDispatch)) {
+        ALOGE("missing device proc: %s", "vkCmdDispatch");
+        success = false;
+    }
+    dispatch.CmdDispatchIndirect = reinterpret_cast<PFN_vkCmdDispatchIndirect>(get_proc_addr(device, "vkCmdDispatchIndirect"));
+    if (UNLIKELY(!dispatch.CmdDispatchIndirect)) {
+        ALOGE("missing device proc: %s", "vkCmdDispatchIndirect");
+        success = false;
+    }
+    dispatch.CmdCopyBuffer = reinterpret_cast<PFN_vkCmdCopyBuffer>(get_proc_addr(device, "vkCmdCopyBuffer"));
+    if (UNLIKELY(!dispatch.CmdCopyBuffer)) {
+        ALOGE("missing device proc: %s", "vkCmdCopyBuffer");
+        success = false;
+    }
+    dispatch.CmdCopyImage = reinterpret_cast<PFN_vkCmdCopyImage>(get_proc_addr(device, "vkCmdCopyImage"));
+    if (UNLIKELY(!dispatch.CmdCopyImage)) {
+        ALOGE("missing device proc: %s", "vkCmdCopyImage");
+        success = false;
+    }
+    dispatch.CmdBlitImage = reinterpret_cast<PFN_vkCmdBlitImage>(get_proc_addr(device, "vkCmdBlitImage"));
+    if (UNLIKELY(!dispatch.CmdBlitImage)) {
+        ALOGE("missing device proc: %s", "vkCmdBlitImage");
+        success = false;
+    }
+    dispatch.CmdCopyBufferToImage = reinterpret_cast<PFN_vkCmdCopyBufferToImage>(get_proc_addr(device, "vkCmdCopyBufferToImage"));
+    if (UNLIKELY(!dispatch.CmdCopyBufferToImage)) {
+        ALOGE("missing device proc: %s", "vkCmdCopyBufferToImage");
+        success = false;
+    }
+    dispatch.CmdCopyImageToBuffer = reinterpret_cast<PFN_vkCmdCopyImageToBuffer>(get_proc_addr(device, "vkCmdCopyImageToBuffer"));
+    if (UNLIKELY(!dispatch.CmdCopyImageToBuffer)) {
+        ALOGE("missing device proc: %s", "vkCmdCopyImageToBuffer");
+        success = false;
+    }
+    dispatch.CmdUpdateBuffer = reinterpret_cast<PFN_vkCmdUpdateBuffer>(get_proc_addr(device, "vkCmdUpdateBuffer"));
+    if (UNLIKELY(!dispatch.CmdUpdateBuffer)) {
+        ALOGE("missing device proc: %s", "vkCmdUpdateBuffer");
+        success = false;
+    }
+    dispatch.CmdFillBuffer = reinterpret_cast<PFN_vkCmdFillBuffer>(get_proc_addr(device, "vkCmdFillBuffer"));
+    if (UNLIKELY(!dispatch.CmdFillBuffer)) {
+        ALOGE("missing device proc: %s", "vkCmdFillBuffer");
+        success = false;
+    }
+    dispatch.CmdClearColorImage = reinterpret_cast<PFN_vkCmdClearColorImage>(get_proc_addr(device, "vkCmdClearColorImage"));
+    if (UNLIKELY(!dispatch.CmdClearColorImage)) {
+        ALOGE("missing device proc: %s", "vkCmdClearColorImage");
+        success = false;
+    }
+    dispatch.CmdClearDepthStencilImage = reinterpret_cast<PFN_vkCmdClearDepthStencilImage>(get_proc_addr(device, "vkCmdClearDepthStencilImage"));
+    if (UNLIKELY(!dispatch.CmdClearDepthStencilImage)) {
+        ALOGE("missing device proc: %s", "vkCmdClearDepthStencilImage");
+        success = false;
+    }
+    dispatch.CmdClearAttachments = reinterpret_cast<PFN_vkCmdClearAttachments>(get_proc_addr(device, "vkCmdClearAttachments"));
+    if (UNLIKELY(!dispatch.CmdClearAttachments)) {
+        ALOGE("missing device proc: %s", "vkCmdClearAttachments");
+        success = false;
+    }
+    dispatch.CmdResolveImage = reinterpret_cast<PFN_vkCmdResolveImage>(get_proc_addr(device, "vkCmdResolveImage"));
+    if (UNLIKELY(!dispatch.CmdResolveImage)) {
+        ALOGE("missing device proc: %s", "vkCmdResolveImage");
+        success = false;
+    }
+    dispatch.CmdSetEvent = reinterpret_cast<PFN_vkCmdSetEvent>(get_proc_addr(device, "vkCmdSetEvent"));
+    if (UNLIKELY(!dispatch.CmdSetEvent)) {
+        ALOGE("missing device proc: %s", "vkCmdSetEvent");
+        success = false;
+    }
+    dispatch.CmdResetEvent = reinterpret_cast<PFN_vkCmdResetEvent>(get_proc_addr(device, "vkCmdResetEvent"));
+    if (UNLIKELY(!dispatch.CmdResetEvent)) {
+        ALOGE("missing device proc: %s", "vkCmdResetEvent");
+        success = false;
+    }
+    dispatch.CmdWaitEvents = reinterpret_cast<PFN_vkCmdWaitEvents>(get_proc_addr(device, "vkCmdWaitEvents"));
+    if (UNLIKELY(!dispatch.CmdWaitEvents)) {
+        ALOGE("missing device proc: %s", "vkCmdWaitEvents");
+        success = false;
+    }
+    dispatch.CmdPipelineBarrier = reinterpret_cast<PFN_vkCmdPipelineBarrier>(get_proc_addr(device, "vkCmdPipelineBarrier"));
+    if (UNLIKELY(!dispatch.CmdPipelineBarrier)) {
+        ALOGE("missing device proc: %s", "vkCmdPipelineBarrier");
+        success = false;
+    }
+    dispatch.CmdBeginQuery = reinterpret_cast<PFN_vkCmdBeginQuery>(get_proc_addr(device, "vkCmdBeginQuery"));
+    if (UNLIKELY(!dispatch.CmdBeginQuery)) {
+        ALOGE("missing device proc: %s", "vkCmdBeginQuery");
+        success = false;
+    }
+    dispatch.CmdEndQuery = reinterpret_cast<PFN_vkCmdEndQuery>(get_proc_addr(device, "vkCmdEndQuery"));
+    if (UNLIKELY(!dispatch.CmdEndQuery)) {
+        ALOGE("missing device proc: %s", "vkCmdEndQuery");
+        success = false;
+    }
+    dispatch.CmdResetQueryPool = reinterpret_cast<PFN_vkCmdResetQueryPool>(get_proc_addr(device, "vkCmdResetQueryPool"));
+    if (UNLIKELY(!dispatch.CmdResetQueryPool)) {
+        ALOGE("missing device proc: %s", "vkCmdResetQueryPool");
+        success = false;
+    }
+    dispatch.CmdWriteTimestamp = reinterpret_cast<PFN_vkCmdWriteTimestamp>(get_proc_addr(device, "vkCmdWriteTimestamp"));
+    if (UNLIKELY(!dispatch.CmdWriteTimestamp)) {
+        ALOGE("missing device proc: %s", "vkCmdWriteTimestamp");
+        success = false;
+    }
+    dispatch.CmdCopyQueryPoolResults = reinterpret_cast<PFN_vkCmdCopyQueryPoolResults>(get_proc_addr(device, "vkCmdCopyQueryPoolResults"));
+    if (UNLIKELY(!dispatch.CmdCopyQueryPoolResults)) {
+        ALOGE("missing device proc: %s", "vkCmdCopyQueryPoolResults");
+        success = false;
+    }
+    dispatch.CmdPushConstants = reinterpret_cast<PFN_vkCmdPushConstants>(get_proc_addr(device, "vkCmdPushConstants"));
+    if (UNLIKELY(!dispatch.CmdPushConstants)) {
+        ALOGE("missing device proc: %s", "vkCmdPushConstants");
+        success = false;
+    }
+    dispatch.CmdBeginRenderPass = reinterpret_cast<PFN_vkCmdBeginRenderPass>(get_proc_addr(device, "vkCmdBeginRenderPass"));
+    if (UNLIKELY(!dispatch.CmdBeginRenderPass)) {
+        ALOGE("missing device proc: %s", "vkCmdBeginRenderPass");
+        success = false;
+    }
+    dispatch.CmdNextSubpass = reinterpret_cast<PFN_vkCmdNextSubpass>(get_proc_addr(device, "vkCmdNextSubpass"));
+    if (UNLIKELY(!dispatch.CmdNextSubpass)) {
+        ALOGE("missing device proc: %s", "vkCmdNextSubpass");
+        success = false;
+    }
+    dispatch.CmdEndRenderPass = reinterpret_cast<PFN_vkCmdEndRenderPass>(get_proc_addr(device, "vkCmdEndRenderPass"));
+    if (UNLIKELY(!dispatch.CmdEndRenderPass)) {
+        ALOGE("missing device proc: %s", "vkCmdEndRenderPass");
+        success = false;
+    }
+    dispatch.CmdExecuteCommands = reinterpret_cast<PFN_vkCmdExecuteCommands>(get_proc_addr(device, "vkCmdExecuteCommands"));
+    if (UNLIKELY(!dispatch.CmdExecuteCommands)) {
+        ALOGE("missing device proc: %s", "vkCmdExecuteCommands");
+        success = false;
+    }
+    dispatch.CreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(get_proc_addr(device, "vkCreateSwapchainKHR"));
+    if (UNLIKELY(!dispatch.CreateSwapchainKHR)) {
+        ALOGE("missing device proc: %s", "vkCreateSwapchainKHR");
+        success = false;
+    }
+    dispatch.DestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(get_proc_addr(device, "vkDestroySwapchainKHR"));
+    if (UNLIKELY(!dispatch.DestroySwapchainKHR)) {
+        ALOGE("missing device proc: %s", "vkDestroySwapchainKHR");
+        success = false;
+    }
+    dispatch.GetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(get_proc_addr(device, "vkGetSwapchainImagesKHR"));
+    if (UNLIKELY(!dispatch.GetSwapchainImagesKHR)) {
+        ALOGE("missing device proc: %s", "vkGetSwapchainImagesKHR");
+        success = false;
+    }
+    dispatch.AcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(get_proc_addr(device, "vkAcquireNextImageKHR"));
+    if (UNLIKELY(!dispatch.AcquireNextImageKHR)) {
+        ALOGE("missing device proc: %s", "vkAcquireNextImageKHR");
+        success = false;
+    }
+    dispatch.QueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(get_proc_addr(device, "vkQueuePresentKHR"));
+    if (UNLIKELY(!dispatch.QueuePresentKHR)) {
+        ALOGE("missing device proc: %s", "vkQueuePresentKHR");
+        success = false;
+    }
+    // clang-format on
+    return success;
+}
+
+bool LoadDriverDispatchTable(VkInstance instance,
+                             PFN_vkGetInstanceProcAddr get_proc_addr,
+                             DriverDispatchTable& dispatch) {
+    bool success = true;
+    // clang-format off
+    dispatch.DestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(get_proc_addr(instance, "vkDestroyInstance"));
+    if (UNLIKELY(!dispatch.DestroyInstance)) {
+        ALOGE("missing driver proc: %s", "vkDestroyInstance");
+        success = false;
+    }
+    dispatch.EnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(get_proc_addr(instance, "vkEnumeratePhysicalDevices"));
+    if (UNLIKELY(!dispatch.EnumeratePhysicalDevices)) {
+        ALOGE("missing driver proc: %s", "vkEnumeratePhysicalDevices");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceProperties)) {
+        ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceProperties");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceQueueFamilyProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceQueueFamilyProperties)) {
+        ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceQueueFamilyProperties");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceMemoryProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceMemoryProperties)) {
+        ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceMemoryProperties");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(get_proc_addr(instance, "vkGetPhysicalDeviceFeatures"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceFeatures)) {
+        ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceFeatures");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceFormatProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceFormatProperties)) {
+        ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceFormatProperties");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceImageFormatProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceImageFormatProperties)) {
+        ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceImageFormatProperties");
+        success = false;
+    }
+    dispatch.CreateDevice = reinterpret_cast<PFN_vkCreateDevice>(get_proc_addr(instance, "vkCreateDevice"));
+    if (UNLIKELY(!dispatch.CreateDevice)) {
+        ALOGE("missing driver proc: %s", "vkCreateDevice");
+        success = false;
+    }
+    dispatch.EnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(get_proc_addr(instance, "vkEnumerateDeviceLayerProperties"));
+    if (UNLIKELY(!dispatch.EnumerateDeviceLayerProperties)) {
+        ALOGE("missing driver proc: %s", "vkEnumerateDeviceLayerProperties");
+        success = false;
+    }
+    dispatch.EnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(get_proc_addr(instance, "vkEnumerateDeviceExtensionProperties"));
+    if (UNLIKELY(!dispatch.EnumerateDeviceExtensionProperties)) {
+        ALOGE("missing driver proc: %s", "vkEnumerateDeviceExtensionProperties");
+        success = false;
+    }
+    dispatch.GetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"));
+    if (UNLIKELY(!dispatch.GetPhysicalDeviceSparseImageFormatProperties)) {
+        ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceSparseImageFormatProperties");
+        success = false;
+    }
+    dispatch.GetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(get_proc_addr(instance, "vkGetDeviceProcAddr"));
+    if (UNLIKELY(!dispatch.GetDeviceProcAddr)) {
+        ALOGE("missing driver proc: %s", "vkGetDeviceProcAddr");
+        success = false;
+    }
+    dispatch.CreateImage = reinterpret_cast<PFN_vkCreateImage>(get_proc_addr(instance, "vkCreateImage"));
+    if (UNLIKELY(!dispatch.CreateImage)) {
+        ALOGE("missing driver proc: %s", "vkCreateImage");
+        success = false;
+    }
+    dispatch.DestroyImage = reinterpret_cast<PFN_vkDestroyImage>(get_proc_addr(instance, "vkDestroyImage"));
+    if (UNLIKELY(!dispatch.DestroyImage)) {
+        ALOGE("missing driver proc: %s", "vkDestroyImage");
+        success = false;
+    }
+    dispatch.AcquireImageANDROID = reinterpret_cast<PFN_vkAcquireImageANDROID>(get_proc_addr(instance, "vkAcquireImageANDROID"));
+    if (UNLIKELY(!dispatch.AcquireImageANDROID)) {
+        ALOGE("missing driver proc: %s", "vkAcquireImageANDROID");
+        success = false;
+    }
+    dispatch.QueueSignalReleaseImageANDROID = reinterpret_cast<PFN_vkQueueSignalReleaseImageANDROID>(get_proc_addr(instance, "vkQueueSignalReleaseImageANDROID"));
+    if (UNLIKELY(!dispatch.QueueSignalReleaseImageANDROID)) {
+        ALOGE("missing driver proc: %s", "vkQueueSignalReleaseImageANDROID");
+        success = false;
+    }
+    // clang-format on
+    return success;
+}
+
+}  // namespace vulkan
+
+// clang-format off
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
+    return CreateInstance_Top(pCreateInfo, pAllocator, pInstance);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
+    DestroyInstance_Top(instance, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
+    return GetDispatchTable(instance).EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) {
+    return GetDeviceProcAddr_Top(device, pName);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
+    return GetInstanceProcAddr_Top(instance, pName);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
+    GetDispatchTable(physicalDevice).GetPhysicalDeviceProperties(physicalDevice, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
+    GetDispatchTable(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
+    GetDispatchTable(physicalDevice).GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+    GetDispatchTable(physicalDevice).GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
+    GetDispatchTable(physicalDevice).GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+    return GetDispatchTable(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
+    return GetDispatchTable(physicalDevice).CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
+    DestroyDevice_Top(device, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+    return EnumerateInstanceLayerProperties_Top(pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+    return EnumerateInstanceExtensionProperties_Top(pLayerName, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+    return GetDispatchTable(physicalDevice).EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+    return GetDispatchTable(physicalDevice).EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
+    GetDeviceQueue_Top(device, queueFamilyIndex, queueIndex, pQueue);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
+    return GetDispatchTable(queue).QueueSubmit(queue, submitCount, pSubmits, fence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueueWaitIdle(VkQueue queue) {
+    return GetDispatchTable(queue).QueueWaitIdle(queue);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkDeviceWaitIdle(VkDevice device) {
+    return GetDispatchTable(device).DeviceWaitIdle(device);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
+    return GetDispatchTable(device).AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).FreeMemory(device, memory, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
+    return GetDispatchTable(device).MapMemory(device, memory, offset, size, flags, ppData);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
+    GetDispatchTable(device).UnmapMemory(device, memory);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+    return GetDispatchTable(device).FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+    return GetDispatchTable(device).InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
+    GetDispatchTable(device).GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
+    GetDispatchTable(device).GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+    return GetDispatchTable(device).BindBufferMemory(device, buffer, memory, memoryOffset);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
+    GetDispatchTable(device).GetImageMemoryRequirements(device, image, pMemoryRequirements);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+    return GetDispatchTable(device).BindImageMemory(device, image, memory, memoryOffset);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+    GetDispatchTable(device).GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
+    GetDispatchTable(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
+    return GetDispatchTable(queue).QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+    return GetDispatchTable(device).CreateFence(device, pCreateInfo, pAllocator, pFence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyFence(device, fence, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
+    return GetDispatchTable(device).ResetFences(device, fenceCount, pFences);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetFenceStatus(VkDevice device, VkFence fence) {
+    return GetDispatchTable(device).GetFenceStatus(device, fence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
+    return GetDispatchTable(device).WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
+    return GetDispatchTable(device).CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroySemaphore(device, semaphore, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
+    return GetDispatchTable(device).CreateEvent(device, pCreateInfo, pAllocator, pEvent);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyEvent(device, event, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetEventStatus(VkDevice device, VkEvent event) {
+    return GetDispatchTable(device).GetEventStatus(device, event);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkSetEvent(VkDevice device, VkEvent event) {
+    return GetDispatchTable(device).SetEvent(device, event);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetEvent(VkDevice device, VkEvent event) {
+    return GetDispatchTable(device).ResetEvent(device, event);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
+    return GetDispatchTable(device).CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyQueryPool(device, queryPool, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
+    return GetDispatchTable(device).GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
+    return GetDispatchTable(device).CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyBuffer(device, buffer, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
+    return GetDispatchTable(device).CreateBufferView(device, pCreateInfo, pAllocator, pView);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyBufferView(device, bufferView, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
+    return GetDispatchTable(device).CreateImage(device, pCreateInfo, pAllocator, pImage);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyImage(device, image, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+    GetDispatchTable(device).GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
+    return GetDispatchTable(device).CreateImageView(device, pCreateInfo, pAllocator, pView);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyImageView(device, imageView, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
+    return GetDispatchTable(device).CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyShaderModule(device, shaderModule, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
+    return GetDispatchTable(device).CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyPipelineCache(device, pipelineCache, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
+    return GetDispatchTable(device).GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
+    return GetDispatchTable(device).MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    return GetDispatchTable(device).CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    return GetDispatchTable(device).CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyPipeline(device, pipeline, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
+    return GetDispatchTable(device).CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyPipelineLayout(device, pipelineLayout, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
+    return GetDispatchTable(device).CreateSampler(device, pCreateInfo, pAllocator, pSampler);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroySampler(device, sampler, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+    return GetDispatchTable(device).CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
+    return GetDispatchTable(device).CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyDescriptorPool(device, descriptorPool, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
+    return GetDispatchTable(device).ResetDescriptorPool(device, descriptorPool, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
+    return GetDispatchTable(device).AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
+    return GetDispatchTable(device).FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
+    GetDispatchTable(device).UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
+    return GetDispatchTable(device).CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyFramebuffer(device, framebuffer, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+    return GetDispatchTable(device).CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyRenderPass(device, renderPass, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+    GetDispatchTable(device).GetRenderAreaGranularity(device, renderPass, pGranularity);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
+    return GetDispatchTable(device).CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroyCommandPool(device, commandPool, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
+    return GetDispatchTable(device).ResetCommandPool(device, commandPool, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
+    return AllocateCommandBuffers_Top(device, pAllocateInfo, pCommandBuffers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
+    GetDispatchTable(device).FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
+    return GetDispatchTable(commandBuffer).BeginCommandBuffer(commandBuffer, pBeginInfo);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
+    return GetDispatchTable(commandBuffer).EndCommandBuffer(commandBuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
+    return GetDispatchTable(commandBuffer).ResetCommandBuffer(commandBuffer, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+    GetDispatchTable(commandBuffer).CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
+    GetDispatchTable(commandBuffer).CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
+    GetDispatchTable(commandBuffer).CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
+    GetDispatchTable(commandBuffer).CmdSetLineWidth(commandBuffer, lineWidth);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
+    GetDispatchTable(commandBuffer).CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
+    GetDispatchTable(commandBuffer).CmdSetBlendConstants(commandBuffer, blendConstants);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
+    GetDispatchTable(commandBuffer).CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
+    GetDispatchTable(commandBuffer).CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
+    GetDispatchTable(commandBuffer).CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
+    GetDispatchTable(commandBuffer).CmdSetStencilReference(commandBuffer, faceMask, reference);
+}
+
+__attribute__((visibility("default")))
+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) {
+    GetDispatchTable(commandBuffer).CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
+    GetDispatchTable(commandBuffer).CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
+    GetDispatchTable(commandBuffer).CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+    GetDispatchTable(commandBuffer).CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+    GetDispatchTable(commandBuffer).CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    GetDispatchTable(commandBuffer).CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    GetDispatchTable(commandBuffer).CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
+    GetDispatchTable(commandBuffer).CmdDispatch(commandBuffer, x, y, z);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
+    GetDispatchTable(commandBuffer).CmdDispatchIndirect(commandBuffer, buffer, offset);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
+    GetDispatchTable(commandBuffer).CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
+    GetDispatchTable(commandBuffer).CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+    GetDispatchTable(commandBuffer).CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+    GetDispatchTable(commandBuffer).CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+    GetDispatchTable(commandBuffer).CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) {
+    GetDispatchTable(commandBuffer).CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+    GetDispatchTable(commandBuffer).CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+    GetDispatchTable(commandBuffer).CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+    GetDispatchTable(commandBuffer).CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+    GetDispatchTable(commandBuffer).CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+    GetDispatchTable(commandBuffer).CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+    GetDispatchTable(commandBuffer).CmdSetEvent(commandBuffer, event, stageMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+    GetDispatchTable(commandBuffer).CmdResetEvent(commandBuffer, event, stageMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
+    GetDispatchTable(commandBuffer).CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
+    GetDispatchTable(commandBuffer).CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {
+    GetDispatchTable(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, query, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
+    GetDispatchTable(commandBuffer).CmdEndQuery(commandBuffer, queryPool, query);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
+    GetDispatchTable(commandBuffer).CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {
+    GetDispatchTable(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
+    GetDispatchTable(commandBuffer).CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {
+    GetDispatchTable(commandBuffer).CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
+    GetDispatchTable(commandBuffer).CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+    GetDispatchTable(commandBuffer).CmdNextSubpass(commandBuffer, contents);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
+    GetDispatchTable(commandBuffer).CmdEndRenderPass(commandBuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
+    GetDispatchTable(commandBuffer).CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(instance).DestroySurfaceKHR(instance, surface, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
+    return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
+    return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
+    return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
+    return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
+    return GetDispatchTable(device).CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
+    GetDispatchTable(device).DestroySwapchainKHR(device, swapchain, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
+    return GetDispatchTable(device).GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
+    return GetDispatchTable(device).AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
+    return GetDispatchTable(queue).QueuePresentKHR(queue, pPresentInfo);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    return GetDispatchTable(instance).CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+}
+
+// clang-format on
diff --git a/vulkan/libvulkan/dispatch_gen.h b/vulkan/libvulkan/dispatch_gen.h
new file mode 100644
index 0000000..809f63e
--- /dev/null
+++ b/vulkan/libvulkan/dispatch_gen.h
@@ -0,0 +1,200 @@
+/*
+ * 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.
+ */
+
+#define VK_PROTOTYPES
+#define VK_USE_PLATFORM_ANDROID_KHR
+#include <vulkan/vk_android_native_buffer.h>
+#include <vulkan/vulkan.h>
+
+namespace vulkan {
+
+struct InstanceDispatchTable {
+    // clang-format off
+    PFN_vkDestroyInstance DestroyInstance;
+    PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
+    PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
+    PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
+    PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
+    PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
+    PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
+    PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
+    PFN_vkCreateDevice CreateDevice;
+    PFN_vkEnumerateDeviceLayerProperties EnumerateDeviceLayerProperties;
+    PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
+    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
+    PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
+    PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
+    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
+    PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
+    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
+    PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
+    // clang-format on
+};
+
+struct DeviceDispatchTable {
+    // clang-format off
+    PFN_vkDestroyDevice DestroyDevice;
+    PFN_vkGetDeviceQueue GetDeviceQueue;
+    PFN_vkQueueSubmit QueueSubmit;
+    PFN_vkQueueWaitIdle QueueWaitIdle;
+    PFN_vkDeviceWaitIdle DeviceWaitIdle;
+    PFN_vkAllocateMemory AllocateMemory;
+    PFN_vkFreeMemory FreeMemory;
+    PFN_vkMapMemory MapMemory;
+    PFN_vkUnmapMemory UnmapMemory;
+    PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges;
+    PFN_vkInvalidateMappedMemoryRanges InvalidateMappedMemoryRanges;
+    PFN_vkGetDeviceMemoryCommitment GetDeviceMemoryCommitment;
+    PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements;
+    PFN_vkBindBufferMemory BindBufferMemory;
+    PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements;
+    PFN_vkBindImageMemory BindImageMemory;
+    PFN_vkGetImageSparseMemoryRequirements GetImageSparseMemoryRequirements;
+    PFN_vkQueueBindSparse QueueBindSparse;
+    PFN_vkCreateFence CreateFence;
+    PFN_vkDestroyFence DestroyFence;
+    PFN_vkResetFences ResetFences;
+    PFN_vkGetFenceStatus GetFenceStatus;
+    PFN_vkWaitForFences WaitForFences;
+    PFN_vkCreateSemaphore CreateSemaphore;
+    PFN_vkDestroySemaphore DestroySemaphore;
+    PFN_vkCreateEvent CreateEvent;
+    PFN_vkDestroyEvent DestroyEvent;
+    PFN_vkGetEventStatus GetEventStatus;
+    PFN_vkSetEvent SetEvent;
+    PFN_vkResetEvent ResetEvent;
+    PFN_vkCreateQueryPool CreateQueryPool;
+    PFN_vkDestroyQueryPool DestroyQueryPool;
+    PFN_vkGetQueryPoolResults GetQueryPoolResults;
+    PFN_vkCreateBuffer CreateBuffer;
+    PFN_vkDestroyBuffer DestroyBuffer;
+    PFN_vkCreateBufferView CreateBufferView;
+    PFN_vkDestroyBufferView DestroyBufferView;
+    PFN_vkCreateImage CreateImage;
+    PFN_vkDestroyImage DestroyImage;
+    PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout;
+    PFN_vkCreateImageView CreateImageView;
+    PFN_vkDestroyImageView DestroyImageView;
+    PFN_vkCreateShaderModule CreateShaderModule;
+    PFN_vkDestroyShaderModule DestroyShaderModule;
+    PFN_vkCreatePipelineCache CreatePipelineCache;
+    PFN_vkDestroyPipelineCache DestroyPipelineCache;
+    PFN_vkGetPipelineCacheData GetPipelineCacheData;
+    PFN_vkMergePipelineCaches MergePipelineCaches;
+    PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines;
+    PFN_vkCreateComputePipelines CreateComputePipelines;
+    PFN_vkDestroyPipeline DestroyPipeline;
+    PFN_vkCreatePipelineLayout CreatePipelineLayout;
+    PFN_vkDestroyPipelineLayout DestroyPipelineLayout;
+    PFN_vkCreateSampler CreateSampler;
+    PFN_vkDestroySampler DestroySampler;
+    PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout;
+    PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout;
+    PFN_vkCreateDescriptorPool CreateDescriptorPool;
+    PFN_vkDestroyDescriptorPool DestroyDescriptorPool;
+    PFN_vkResetDescriptorPool ResetDescriptorPool;
+    PFN_vkAllocateDescriptorSets AllocateDescriptorSets;
+    PFN_vkFreeDescriptorSets FreeDescriptorSets;
+    PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
+    PFN_vkCreateFramebuffer CreateFramebuffer;
+    PFN_vkDestroyFramebuffer DestroyFramebuffer;
+    PFN_vkCreateRenderPass CreateRenderPass;
+    PFN_vkDestroyRenderPass DestroyRenderPass;
+    PFN_vkGetRenderAreaGranularity GetRenderAreaGranularity;
+    PFN_vkCreateCommandPool CreateCommandPool;
+    PFN_vkDestroyCommandPool DestroyCommandPool;
+    PFN_vkResetCommandPool ResetCommandPool;
+    PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
+    PFN_vkFreeCommandBuffers FreeCommandBuffers;
+    PFN_vkBeginCommandBuffer BeginCommandBuffer;
+    PFN_vkEndCommandBuffer EndCommandBuffer;
+    PFN_vkResetCommandBuffer ResetCommandBuffer;
+    PFN_vkCmdBindPipeline CmdBindPipeline;
+    PFN_vkCmdSetViewport CmdSetViewport;
+    PFN_vkCmdSetScissor CmdSetScissor;
+    PFN_vkCmdSetLineWidth CmdSetLineWidth;
+    PFN_vkCmdSetDepthBias CmdSetDepthBias;
+    PFN_vkCmdSetBlendConstants CmdSetBlendConstants;
+    PFN_vkCmdSetDepthBounds CmdSetDepthBounds;
+    PFN_vkCmdSetStencilCompareMask CmdSetStencilCompareMask;
+    PFN_vkCmdSetStencilWriteMask CmdSetStencilWriteMask;
+    PFN_vkCmdSetStencilReference CmdSetStencilReference;
+    PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets;
+    PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer;
+    PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers;
+    PFN_vkCmdDraw CmdDraw;
+    PFN_vkCmdDrawIndexed CmdDrawIndexed;
+    PFN_vkCmdDrawIndirect CmdDrawIndirect;
+    PFN_vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect;
+    PFN_vkCmdDispatch CmdDispatch;
+    PFN_vkCmdDispatchIndirect CmdDispatchIndirect;
+    PFN_vkCmdCopyBuffer CmdCopyBuffer;
+    PFN_vkCmdCopyImage CmdCopyImage;
+    PFN_vkCmdBlitImage CmdBlitImage;
+    PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage;
+    PFN_vkCmdCopyImageToBuffer CmdCopyImageToBuffer;
+    PFN_vkCmdUpdateBuffer CmdUpdateBuffer;
+    PFN_vkCmdFillBuffer CmdFillBuffer;
+    PFN_vkCmdClearColorImage CmdClearColorImage;
+    PFN_vkCmdClearDepthStencilImage CmdClearDepthStencilImage;
+    PFN_vkCmdClearAttachments CmdClearAttachments;
+    PFN_vkCmdResolveImage CmdResolveImage;
+    PFN_vkCmdSetEvent CmdSetEvent;
+    PFN_vkCmdResetEvent CmdResetEvent;
+    PFN_vkCmdWaitEvents CmdWaitEvents;
+    PFN_vkCmdPipelineBarrier CmdPipelineBarrier;
+    PFN_vkCmdBeginQuery CmdBeginQuery;
+    PFN_vkCmdEndQuery CmdEndQuery;
+    PFN_vkCmdResetQueryPool CmdResetQueryPool;
+    PFN_vkCmdWriteTimestamp CmdWriteTimestamp;
+    PFN_vkCmdCopyQueryPoolResults CmdCopyQueryPoolResults;
+    PFN_vkCmdPushConstants CmdPushConstants;
+    PFN_vkCmdBeginRenderPass CmdBeginRenderPass;
+    PFN_vkCmdNextSubpass CmdNextSubpass;
+    PFN_vkCmdEndRenderPass CmdEndRenderPass;
+    PFN_vkCmdExecuteCommands CmdExecuteCommands;
+    PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
+    PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
+    PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
+    PFN_vkAcquireNextImageKHR AcquireNextImageKHR;
+    PFN_vkQueuePresentKHR QueuePresentKHR;
+    // clang-format on
+};
+
+struct DriverDispatchTable {
+    // clang-format off
+    PFN_vkDestroyInstance DestroyInstance;
+    PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
+    PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
+    PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
+    PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
+    PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
+    PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
+    PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
+    PFN_vkCreateDevice CreateDevice;
+    PFN_vkEnumerateDeviceLayerProperties EnumerateDeviceLayerProperties;
+    PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
+    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
+    PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
+    PFN_vkCreateImage CreateImage;
+    PFN_vkDestroyImage DestroyImage;
+    PFN_vkGetSwapchainGrallocUsageANDROID GetSwapchainGrallocUsageANDROID;
+    PFN_vkAcquireImageANDROID AcquireImageANDROID;
+    PFN_vkQueueSignalReleaseImageANDROID QueueSignalReleaseImageANDROID;
+    // clang-format on
+};
+
+}  // namespace vulkan
diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
deleted file mode 100644
index 9c0444f..0000000
--- a/vulkan/libvulkan/entry.cpp
+++ /dev/null
@@ -1,782 +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.
-*/
-
-// This file is generated. Do not edit manually!
-// To regenerate: $ apic template ../api/vulkan.api entry.cpp.tmpl
-// Requires apic from https://android.googlesource.com/platform/tools/gpu/.
-
-#include "loader.h"
-using namespace vulkan;
-
-// clang-format off
-
-namespace {
-    inline const InstanceVtbl& GetVtbl(VkInstance instance) {
-        return **reinterpret_cast<InstanceVtbl**>(instance);
-    }
-    inline const InstanceVtbl& GetVtbl(VkPhysicalDevice physicalDevice) {
-        return **reinterpret_cast<InstanceVtbl**>(physicalDevice);
-    }
-    inline const DeviceVtbl& GetVtbl(VkDevice device) {
-        return **reinterpret_cast<DeviceVtbl**>(device);
-    }
-    inline const DeviceVtbl& GetVtbl(VkQueue queue) {
-        return **reinterpret_cast<DeviceVtbl**>(queue);
-    }
-    inline const DeviceVtbl& GetVtbl(VkCommandBuffer commandBuffer) {
-        return **reinterpret_cast<DeviceVtbl**>(commandBuffer);
-    }
-} // namespace
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
-    return vulkan::CreateInstance(pCreateInfo, pAllocator, pInstance);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(instance).DestroyInstance(instance, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
-    return GetVtbl(instance).EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) {
-    return vulkan::GetDeviceProcAddr(device, pName);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
-    return vulkan::GetInstanceProcAddr(instance, pName);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
-    GetVtbl(physicalDevice).GetPhysicalDeviceProperties(physicalDevice, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
-    GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
-    GetVtbl(physicalDevice).GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
-    GetVtbl(physicalDevice).GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
-    GetVtbl(physicalDevice).GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
-}
-
-__attribute__((visibility("default")))
-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")))
-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")))
-VKAPI_ATTR void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
-    vulkan::DestroyDevice(device, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
-    return vulkan::EnumerateInstanceLayerProperties(pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
-    return vulkan::EnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
-    return GetVtbl(physicalDevice).EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
-    vulkan::GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR VkResult vkQueueWaitIdle(VkQueue queue) {
-    return GetVtbl(queue).QueueWaitIdle(queue);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkDeviceWaitIdle(VkDevice device) {
-    return GetVtbl(device).DeviceWaitIdle(device);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).FreeMemory(device, memory, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
-    GetVtbl(device).UnmapMemory(device, memory);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
-    return GetVtbl(device).FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
-    return GetVtbl(device).InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
-    GetVtbl(device).GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
-    GetVtbl(device).GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
-    return GetVtbl(device).BindBufferMemory(device, buffer, memory, memoryOffset);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
-    GetVtbl(device).GetImageMemoryRequirements(device, image, pMemoryRequirements);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
-    return GetVtbl(device).BindImageMemory(device, image, memory, memoryOffset);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
-    GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-}
-
-__attribute__((visibility("default")))
-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")))
-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")))
-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")))
-VKAPI_ATTR void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyFence(device, fence, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
-    return GetVtbl(device).ResetFences(device, fenceCount, pFences);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetFenceStatus(VkDevice device, VkFence fence) {
-    return GetVtbl(device).GetFenceStatus(device, fence);
-}
-
-__attribute__((visibility("default")))
-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")))
-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")))
-VKAPI_ATTR void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroySemaphore(device, semaphore, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyEvent(device, event, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetEventStatus(VkDevice device, VkEvent event) {
-    return GetVtbl(device).GetEventStatus(device, event);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkSetEvent(VkDevice device, VkEvent event) {
-    return GetVtbl(device).SetEvent(device, event);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetEvent(VkDevice device, VkEvent event) {
-    return GetVtbl(device).ResetEvent(device, event);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyQueryPool(device, queryPool, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-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")))
-VKAPI_ATTR void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyBuffer(device, buffer, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyBufferView(device, bufferView, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyImage(device, image, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
-    GetVtbl(device).GetImageSubresourceLayout(device, image, pSubresource, pLayout);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyImageView(device, imageView, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyShaderModule(device, shaderModule, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyPipelineCache(device, pipelineCache, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
-    return GetVtbl(device).GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
-}
-
-__attribute__((visibility("default")))
-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")))
-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")))
-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")))
-VKAPI_ATTR void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyPipeline(device, pipeline, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyPipelineLayout(device, pipelineLayout, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroySampler(device, sampler, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyDescriptorPool(device, descriptorPool, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
-    return GetVtbl(device).ResetDescriptorPool(device, descriptorPool, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
-    return GetVtbl(device).AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
-}
-
-__attribute__((visibility("default")))
-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")))
-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")))
-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")))
-VKAPI_ATTR void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyFramebuffer(device, framebuffer, pAllocator);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyRenderPass(device, renderPass, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
-    GetVtbl(device).GetRenderAreaGranularity(device, renderPass, pGranularity);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroyCommandPool(device, commandPool, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
-    return GetVtbl(device).ResetCommandPool(device, commandPool, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
-    return GetVtbl(device).AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
-    GetVtbl(device).FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
-    return GetVtbl(commandBuffer).BeginCommandBuffer(commandBuffer, pBeginInfo);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
-    return GetVtbl(commandBuffer).EndCommandBuffer(commandBuffer);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
-    return GetVtbl(commandBuffer).ResetCommandBuffer(commandBuffer, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
-    GetVtbl(commandBuffer).CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
-    GetVtbl(commandBuffer).CmdSetViewport(commandBuffer, viewportCount, pViewports);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
-    GetVtbl(commandBuffer).CmdSetScissor(commandBuffer, scissorCount, pScissors);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
-    GetVtbl(commandBuffer).CmdSetLineWidth(commandBuffer, lineWidth);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
-    GetVtbl(commandBuffer).CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
-    GetVtbl(commandBuffer).CmdSetBlendConstants(commandBuffer, blendConstants);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
-    GetVtbl(commandBuffer).CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
-    GetVtbl(commandBuffer).CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
-    GetVtbl(commandBuffer).CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
-    GetVtbl(commandBuffer).CmdSetStencilReference(commandBuffer, faceMask, reference);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
-    GetVtbl(commandBuffer).CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
-}
-
-__attribute__((visibility("default")))
-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")))
-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")))
-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")))
-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")))
-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")))
-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")))
-VKAPI_ATTR void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
-    GetVtbl(commandBuffer).CmdDispatchIndirect(commandBuffer, buffer, offset);
-}
-
-__attribute__((visibility("default")))
-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")))
-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")))
-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")))
-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")))
-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")))
-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")))
-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")))
-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")))
-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")))
-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")))
-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")))
-VKAPI_ATTR void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
-    GetVtbl(commandBuffer).CmdSetEvent(commandBuffer, event, stageMask);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
-    GetVtbl(commandBuffer).CmdResetEvent(commandBuffer, event, stageMask);
-}
-
-__attribute__((visibility("default")))
-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")))
-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")))
-VKAPI_ATTR void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags) {
-    GetVtbl(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, entry, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry) {
-    GetVtbl(commandBuffer).CmdEndQuery(commandBuffer, queryPool, entry);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
-    GetVtbl(commandBuffer).CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry) {
-    GetVtbl(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, entry);
-}
-
-__attribute__((visibility("default")))
-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")))
-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")))
-VKAPI_ATTR void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
-    GetVtbl(commandBuffer).CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
-    GetVtbl(commandBuffer).CmdNextSubpass(commandBuffer, contents);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
-    GetVtbl(commandBuffer).CmdEndRenderPass(commandBuffer);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers) {
-    GetVtbl(commandBuffer).CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(instance).DestroySurfaceKHR(instance, surface, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
-    return GetVtbl(physicalDevice).GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
-}
-
-__attribute__((visibility("default")))
-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, const VkAllocationCallbacks* pAllocator) {
-    GetVtbl(device).DestroySwapchainKHR(device, swapchain, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
-    return GetVtbl(device).GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
-}
-
-__attribute__((visibility("default")))
-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")))
-VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
-    return GetVtbl(queue).QueuePresentKHR(queue, pPresentInfo);
-}
-
-__attribute__((visibility("default")))
-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/entry.cpp.tmpl b/vulkan/libvulkan/entry.cpp.tmpl
deleted file mode 100644
index 5047741..0000000
--- a/vulkan/libvulkan/entry.cpp.tmpl
+++ /dev/null
@@ -1,182 +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.
- */}}
-
-{{Include "../api/templates/vulkan_common.tmpl"}}
-{{Macro "DefineGlobals" $}}
-{{$ | Macro "entry.cpp" | Reflow 4 | Write "entry.cpp"}}
-
-
-{{/*
--------------------------------------------------------------------------------
-  Entry point
--------------------------------------------------------------------------------
-*/}}
-{{define "entry.cpp"}}
-/*
- * 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.
- */
-¶
-// This file is generated. Do not edit manually!
-// To regenerate: $ apic template ../api/vulkan.api entry.cpp.tmpl
-// Requires apic from https://android.googlesource.com/platform/tools/gpu/.
-¶
-#include "loader.h"
-using namespace vulkan;
-¶
-// clang-format off
-¶
-namespace {
-    inline const InstanceVtbl& GetVtbl(VkInstance instance) {
-        return **reinterpret_cast<InstanceVtbl**>(instance);
-    }
-    inline const InstanceVtbl& GetVtbl(VkPhysicalDevice physicalDevice) {
-        return **reinterpret_cast<InstanceVtbl**>(physicalDevice);
-    }
-    inline const DeviceVtbl& GetVtbl(VkDevice device) {
-        return **reinterpret_cast<DeviceVtbl**>(device);
-    }
-    inline const DeviceVtbl& GetVtbl(VkQueue queue) {
-        return **reinterpret_cast<DeviceVtbl**>(queue);
-    }
-    inline const DeviceVtbl& GetVtbl(VkCommandBuffer commandBuffer) {
-        return **reinterpret_cast<DeviceVtbl**>(commandBuffer);
-    }
-} // namespace
-¶
-  {{range $f := AllCommands $}}
-    {{if and (not (GetAnnotation $f "pfn")) (Macro "IsExportedEntry" $f)}}
-      __attribute__((visibility("default")))
-      {{if eq (Macro "IsSpecialEntry" $f.Name) "true"}}
-        {{Macro "EmitSpecialEntry" $f}}
-      {{else}}
-        {{Macro "EmitEntry" $f}}
-      {{end}}
-    {{end}}
-  {{end}}
-
-{{end}}
-
-
-{{/*
--------------------------------------------------------------------------------
-  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_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}}
-
-
-{{/*
--------------------------------------------------------------------------------
-  Decides whether an entrypoint needs special-case handling. Emits the string
-  "true" if so, nothing otherwise.
--------------------------------------------------------------------------------
-*/}}
-{{define "IsSpecialEntry"}}
-  {{/* TODO: figure out how to do this in a cleaner or at least multi-line way */}}
-  {{if or (eq $ "vkGetInstanceProcAddr") (or (eq $ "vkGetDeviceProcAddr") (or (eq $ "vkGetDeviceQueue") (or (eq $ "vkCreateCommandBuffer") (eq $ "vkDestroyDevice"))))}}
-    true
-  {{end}}
-{{end}}
-
-
-{{/*
--------------------------------------------------------------------------------
-  Emits the entrypoint definition for the specified command, which always
-  dispatches statically because the function requires special-case handling.
--------------------------------------------------------------------------------
-*/}}
-{{define "EmitSpecialEntry"}}
-  {{AssertType $ "Function"}}
-
-  VKAPI_ATTR {{Node "Type" $.Return}} {{Macro "FunctionName" $}}({{Macro "Parameters" $}}) {
-    {{if not (IsVoid $.Return.Type)}}return §{{end}}
-    vulkan::{{TrimPrefix "vk" $.Name}}({{Macro "Arguments" $}});
-  }
-  ¶
-{{end}}
-
-
-{{/*
--------------------------------------------------------------------------------
-  Emits the entrypoint definition for the specified command. If the first
-  parameter is a handle to dispatchable object, it dispatches the call through
-  the object's function table. Otherwise, it dispatches statically.
--------------------------------------------------------------------------------
-*/}}
-{{define "EmitEntry"}}
-  {{AssertType $ "Function"}}
-
-  VKAPI_ATTR {{Node "Type" $.Return}} {{Macro "FunctionName" $}}({{Macro "Parameters" $}}) {
-    {{if not (IsVoid $.Return.Type)}}return §{{end}}
-    {{Macro "Dispatch" $}}{{TrimPrefix "vk" $.Name}}({{Macro "Arguments" $}});
-  }
-  ¶
-{{end}}
-
-
-{{/*
--------------------------------------------------------------------------------
-  Emit the dispatch lookup for a function based on its first parameter.
--------------------------------------------------------------------------------
-*/}}
-{{define "Dispatch#VkInstance"      }}GetVtbl({{$.Node.Name}}).{{end}}
-{{define "Dispatch#VkPhysicalDevice"}}GetVtbl({{$.Node.Name}}).{{end}}
-{{define "Dispatch#VkDevice"        }}GetVtbl({{$.Node.Name}}).{{end}}
-{{define "Dispatch#VkQueue"         }}GetVtbl({{$.Node.Name}}).{{end}}
-{{define "Dispatch#VkCommandBuffer" }}GetVtbl({{$.Node.Name}}).{{end}}
-{{define "Dispatch_Default"         }}vulkan::{{end}}
-{{define "Dispatch"}}
-  {{AssertType $ "Function"}}
-
-  {{range $i, $p := $.CallParameters}}
-    {{if not $i}}{{Node "Dispatch" $p}}{{end}}
-  {{end}}
-{{end}}
-
-
-{{/*
--------------------------------------------------------------------------------
-  Emits a comma-separated list of C parameter names for the given command.
--------------------------------------------------------------------------------
-*/}}
-{{define "Arguments"}}
-  {{AssertType $ "Function"}}
-
-  {{ForEach $.CallParameters "ParameterName" | JoinWith ", "}}
-{{end}}
diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
deleted file mode 100644
index 7f1f54e..0000000
--- a/vulkan/libvulkan/get_proc_addr.cpp
+++ /dev/null
@@ -1,1162 +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.
-*/
-
-// This file is generated. Do not edit manually!
-// To regenerate: $ apic template ../api/vulkan.api get_proc_addr.cpp.tmpl
-// Requires apic from https://android.googlesource.com/platform/tools/gpu/.
-
-#include <algorithm>
-#include <log/log.h>
-#include "loader.h"
-using namespace vulkan;
-
-#define UNLIKELY(expr) __builtin_expect((expr), 0)
-
-namespace {
-
-struct NameProcEntry {
-    const char* name;
-    PFN_vkVoidFunction proc;
-};
-
-struct NameOffsetEntry {
-    const char* name;
-    size_t offset;
-};
-
-template <typename TEntry, size_t N>
-const TEntry* FindProcEntry(const TEntry (&table)[N], const char* name) {
-    auto entry = std::lower_bound(
-        table, table + N, name,
-        [](const TEntry& e, const char* n) { return strcmp(e.name, n) < 0; });
-    if (entry != (table + N) && strcmp(entry->name, name) == 0)
-        return entry;
-    return nullptr;
-}
-
-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)},
-    {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetInstanceProcAddr)},
-    {"vkGetPhysicalDeviceFeatures", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFeatures)},
-    {"vkGetPhysicalDeviceFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFormatProperties)},
-    {"vkGetPhysicalDeviceImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceImageFormatProperties)},
-    {"vkGetPhysicalDeviceMemoryProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMemoryProperties)},
-    {"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
-};
-
-const NameProcEntry kDeviceProcTbl[] = {
-    // clang-format off
-    {"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR)},
-    {"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)},
-    {"vkCmdBeginQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginQuery)},
-    {"vkCmdBeginRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass)},
-    {"vkCmdBindDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets)},
-    {"vkCmdBindIndexBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer)},
-    {"vkCmdBindPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipeline)},
-    {"vkCmdBindVertexBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers)},
-    {"vkCmdBlitImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage)},
-    {"vkCmdClearAttachments", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearAttachments)},
-    {"vkCmdClearColorImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearColorImage)},
-    {"vkCmdClearDepthStencilImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearDepthStencilImage)},
-    {"vkCmdCopyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer)},
-    {"vkCmdCopyBufferToImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage)},
-    {"vkCmdCopyImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage)},
-    {"vkCmdCopyImageToBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer)},
-    {"vkCmdCopyQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyQueryPoolResults)},
-    {"vkCmdDispatch", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatch)},
-    {"vkCmdDispatchIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchIndirect)},
-    {"vkCmdDraw", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDraw)},
-    {"vkCmdDrawIndexed", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexed)},
-    {"vkCmdDrawIndexedIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirect)},
-    {"vkCmdDrawIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirect)},
-    {"vkCmdEndQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndQuery)},
-    {"vkCmdEndRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass)},
-    {"vkCmdExecuteCommands", reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteCommands)},
-    {"vkCmdFillBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdFillBuffer)},
-    {"vkCmdNextSubpass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass)},
-    {"vkCmdPipelineBarrier", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier)},
-    {"vkCmdPushConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants)},
-    {"vkCmdResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent)},
-    {"vkCmdResetQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetQueryPool)},
-    {"vkCmdResolveImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage)},
-    {"vkCmdSetBlendConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetBlendConstants)},
-    {"vkCmdSetDepthBias", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBias)},
-    {"vkCmdSetDepthBounds", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBounds)},
-    {"vkCmdSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent)},
-    {"vkCmdSetLineWidth", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineWidth)},
-    {"vkCmdSetScissor", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissor)},
-    {"vkCmdSetStencilCompareMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilCompareMask)},
-    {"vkCmdSetStencilReference", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilReference)},
-    {"vkCmdSetStencilWriteMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilWriteMask)},
-    {"vkCmdSetViewport", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewport)},
-    {"vkCmdUpdateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdUpdateBuffer)},
-    {"vkCmdWaitEvents", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents)},
-    {"vkCmdWriteTimestamp", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp)},
-    {"vkCreateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBuffer)},
-    {"vkCreateBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferView)},
-    {"vkCreateCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateCommandPool)},
-    {"vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateComputePipelines)},
-    {"vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorPool)},
-    {"vkCreateDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorSetLayout)},
-    {"vkCreateEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCreateEvent)},
-    {"vkCreateFence", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFence)},
-    {"vkCreateFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFramebuffer)},
-    {"vkCreateGraphicsPipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateGraphicsPipelines)},
-    {"vkCreateImage", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImage)},
-    {"vkCreateImageView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImageView)},
-    {"vkCreatePipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineCache)},
-    {"vkCreatePipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineLayout)},
-    {"vkCreateQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateQueryPool)},
-    {"vkCreateRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass)},
-    {"vkCreateSampler", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSampler)},
-    {"vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSemaphore)},
-    {"vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkCreateShaderModule)},
-    {"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR)},
-    {"vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer)},
-    {"vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferView)},
-    {"vkDestroyCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandPool)},
-    {"vkDestroyDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorPool)},
-    {"vkDestroyDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorSetLayout)},
-    {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDevice)},
-    {"vkDestroyEvent", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyEvent)},
-    {"vkDestroyFence", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFence)},
-    {"vkDestroyFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFramebuffer)},
-    {"vkDestroyImage", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImage)},
-    {"vkDestroyImageView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImageView)},
-    {"vkDestroyPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipeline)},
-    {"vkDestroyPipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineCache)},
-    {"vkDestroyPipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineLayout)},
-    {"vkDestroyQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyQueryPool)},
-    {"vkDestroyRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyRenderPass)},
-    {"vkDestroySampler", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySampler)},
-    {"vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySemaphore)},
-    {"vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderModule)},
-    {"vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR)},
-    {"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)},
-    {"vkGetDeviceMemoryCommitment", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryCommitment)},
-    {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr)},
-    {"vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceQueue)},
-    {"vkGetEventStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetEventStatus)},
-    {"vkGetFenceStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceStatus)},
-    {"vkGetImageMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements)},
-    {"vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements)},
-    {"vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout)},
-    {"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData)},
-    {"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults)},
-    {"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity)},
-    {"vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR)},
-    {"vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges)},
-    {"vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory)},
-    {"vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(vkMergePipelineCaches)},
-    {"vkQueueBindSparse", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparse)},
-    {"vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR)},
-    {"vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit)},
-    {"vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle)},
-    {"vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandBuffer)},
-    {"vkResetCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandPool)},
-    {"vkResetDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetDescriptorPool)},
-    {"vkResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkResetEvent)},
-    {"vkResetFences", reinterpret_cast<PFN_vkVoidFunction>(vkResetFences)},
-    {"vkSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkSetEvent)},
-    {"vkUnmapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory)},
-    {"vkUpdateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSets)},
-    {"vkWaitForFences", reinterpret_cast<PFN_vkVoidFunction>(vkWaitForFences)},
-    // clang-format on
-};
-
-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)},
-    {"vkGetInstanceProcAddr", offsetof(InstanceVtbl, GetInstanceProcAddr)},
-    {"vkGetPhysicalDeviceFeatures", offsetof(InstanceVtbl, GetPhysicalDeviceFeatures)},
-    {"vkGetPhysicalDeviceFormatProperties", offsetof(InstanceVtbl, GetPhysicalDeviceFormatProperties)},
-    {"vkGetPhysicalDeviceImageFormatProperties", offsetof(InstanceVtbl, GetPhysicalDeviceImageFormatProperties)},
-    {"vkGetPhysicalDeviceMemoryProperties", offsetof(InstanceVtbl, GetPhysicalDeviceMemoryProperties)},
-    {"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
-};
-
-const NameOffsetEntry kDeviceOffsetTbl[] = {
-    // clang-format off
-    {"vkAcquireNextImageKHR", offsetof(DeviceVtbl, AcquireNextImageKHR)},
-    {"vkAllocateCommandBuffers", offsetof(DeviceVtbl, AllocateCommandBuffers)},
-    {"vkAllocateDescriptorSets", offsetof(DeviceVtbl, AllocateDescriptorSets)},
-    {"vkAllocateMemory", offsetof(DeviceVtbl, AllocateMemory)},
-    {"vkBeginCommandBuffer", offsetof(DeviceVtbl, BeginCommandBuffer)},
-    {"vkBindBufferMemory", offsetof(DeviceVtbl, BindBufferMemory)},
-    {"vkBindImageMemory", offsetof(DeviceVtbl, BindImageMemory)},
-    {"vkCmdBeginQuery", offsetof(DeviceVtbl, CmdBeginQuery)},
-    {"vkCmdBeginRenderPass", offsetof(DeviceVtbl, CmdBeginRenderPass)},
-    {"vkCmdBindDescriptorSets", offsetof(DeviceVtbl, CmdBindDescriptorSets)},
-    {"vkCmdBindIndexBuffer", offsetof(DeviceVtbl, CmdBindIndexBuffer)},
-    {"vkCmdBindPipeline", offsetof(DeviceVtbl, CmdBindPipeline)},
-    {"vkCmdBindVertexBuffers", offsetof(DeviceVtbl, CmdBindVertexBuffers)},
-    {"vkCmdBlitImage", offsetof(DeviceVtbl, CmdBlitImage)},
-    {"vkCmdClearAttachments", offsetof(DeviceVtbl, CmdClearAttachments)},
-    {"vkCmdClearColorImage", offsetof(DeviceVtbl, CmdClearColorImage)},
-    {"vkCmdClearDepthStencilImage", offsetof(DeviceVtbl, CmdClearDepthStencilImage)},
-    {"vkCmdCopyBuffer", offsetof(DeviceVtbl, CmdCopyBuffer)},
-    {"vkCmdCopyBufferToImage", offsetof(DeviceVtbl, CmdCopyBufferToImage)},
-    {"vkCmdCopyImage", offsetof(DeviceVtbl, CmdCopyImage)},
-    {"vkCmdCopyImageToBuffer", offsetof(DeviceVtbl, CmdCopyImageToBuffer)},
-    {"vkCmdCopyQueryPoolResults", offsetof(DeviceVtbl, CmdCopyQueryPoolResults)},
-    {"vkCmdDispatch", offsetof(DeviceVtbl, CmdDispatch)},
-    {"vkCmdDispatchIndirect", offsetof(DeviceVtbl, CmdDispatchIndirect)},
-    {"vkCmdDraw", offsetof(DeviceVtbl, CmdDraw)},
-    {"vkCmdDrawIndexed", offsetof(DeviceVtbl, CmdDrawIndexed)},
-    {"vkCmdDrawIndexedIndirect", offsetof(DeviceVtbl, CmdDrawIndexedIndirect)},
-    {"vkCmdDrawIndirect", offsetof(DeviceVtbl, CmdDrawIndirect)},
-    {"vkCmdEndQuery", offsetof(DeviceVtbl, CmdEndQuery)},
-    {"vkCmdEndRenderPass", offsetof(DeviceVtbl, CmdEndRenderPass)},
-    {"vkCmdExecuteCommands", offsetof(DeviceVtbl, CmdExecuteCommands)},
-    {"vkCmdFillBuffer", offsetof(DeviceVtbl, CmdFillBuffer)},
-    {"vkCmdNextSubpass", offsetof(DeviceVtbl, CmdNextSubpass)},
-    {"vkCmdPipelineBarrier", offsetof(DeviceVtbl, CmdPipelineBarrier)},
-    {"vkCmdPushConstants", offsetof(DeviceVtbl, CmdPushConstants)},
-    {"vkCmdResetEvent", offsetof(DeviceVtbl, CmdResetEvent)},
-    {"vkCmdResetQueryPool", offsetof(DeviceVtbl, CmdResetQueryPool)},
-    {"vkCmdResolveImage", offsetof(DeviceVtbl, CmdResolveImage)},
-    {"vkCmdSetBlendConstants", offsetof(DeviceVtbl, CmdSetBlendConstants)},
-    {"vkCmdSetDepthBias", offsetof(DeviceVtbl, CmdSetDepthBias)},
-    {"vkCmdSetDepthBounds", offsetof(DeviceVtbl, CmdSetDepthBounds)},
-    {"vkCmdSetEvent", offsetof(DeviceVtbl, CmdSetEvent)},
-    {"vkCmdSetLineWidth", offsetof(DeviceVtbl, CmdSetLineWidth)},
-    {"vkCmdSetScissor", offsetof(DeviceVtbl, CmdSetScissor)},
-    {"vkCmdSetStencilCompareMask", offsetof(DeviceVtbl, CmdSetStencilCompareMask)},
-    {"vkCmdSetStencilReference", offsetof(DeviceVtbl, CmdSetStencilReference)},
-    {"vkCmdSetStencilWriteMask", offsetof(DeviceVtbl, CmdSetStencilWriteMask)},
-    {"vkCmdSetViewport", offsetof(DeviceVtbl, CmdSetViewport)},
-    {"vkCmdUpdateBuffer", offsetof(DeviceVtbl, CmdUpdateBuffer)},
-    {"vkCmdWaitEvents", offsetof(DeviceVtbl, CmdWaitEvents)},
-    {"vkCmdWriteTimestamp", offsetof(DeviceVtbl, CmdWriteTimestamp)},
-    {"vkCreateBuffer", offsetof(DeviceVtbl, CreateBuffer)},
-    {"vkCreateBufferView", offsetof(DeviceVtbl, CreateBufferView)},
-    {"vkCreateCommandPool", offsetof(DeviceVtbl, CreateCommandPool)},
-    {"vkCreateComputePipelines", offsetof(DeviceVtbl, CreateComputePipelines)},
-    {"vkCreateDescriptorPool", offsetof(DeviceVtbl, CreateDescriptorPool)},
-    {"vkCreateDescriptorSetLayout", offsetof(DeviceVtbl, CreateDescriptorSetLayout)},
-    {"vkCreateEvent", offsetof(DeviceVtbl, CreateEvent)},
-    {"vkCreateFence", offsetof(DeviceVtbl, CreateFence)},
-    {"vkCreateFramebuffer", offsetof(DeviceVtbl, CreateFramebuffer)},
-    {"vkCreateGraphicsPipelines", offsetof(DeviceVtbl, CreateGraphicsPipelines)},
-    {"vkCreateImage", offsetof(DeviceVtbl, CreateImage)},
-    {"vkCreateImageView", offsetof(DeviceVtbl, CreateImageView)},
-    {"vkCreatePipelineCache", offsetof(DeviceVtbl, CreatePipelineCache)},
-    {"vkCreatePipelineLayout", offsetof(DeviceVtbl, CreatePipelineLayout)},
-    {"vkCreateQueryPool", offsetof(DeviceVtbl, CreateQueryPool)},
-    {"vkCreateRenderPass", offsetof(DeviceVtbl, CreateRenderPass)},
-    {"vkCreateSampler", offsetof(DeviceVtbl, CreateSampler)},
-    {"vkCreateSemaphore", offsetof(DeviceVtbl, CreateSemaphore)},
-    {"vkCreateShaderModule", offsetof(DeviceVtbl, CreateShaderModule)},
-    {"vkCreateSwapchainKHR", offsetof(DeviceVtbl, CreateSwapchainKHR)},
-    {"vkDestroyBuffer", offsetof(DeviceVtbl, DestroyBuffer)},
-    {"vkDestroyBufferView", offsetof(DeviceVtbl, DestroyBufferView)},
-    {"vkDestroyCommandPool", offsetof(DeviceVtbl, DestroyCommandPool)},
-    {"vkDestroyDescriptorPool", offsetof(DeviceVtbl, DestroyDescriptorPool)},
-    {"vkDestroyDescriptorSetLayout", offsetof(DeviceVtbl, DestroyDescriptorSetLayout)},
-    {"vkDestroyDevice", offsetof(DeviceVtbl, DestroyDevice)},
-    {"vkDestroyEvent", offsetof(DeviceVtbl, DestroyEvent)},
-    {"vkDestroyFence", offsetof(DeviceVtbl, DestroyFence)},
-    {"vkDestroyFramebuffer", offsetof(DeviceVtbl, DestroyFramebuffer)},
-    {"vkDestroyImage", offsetof(DeviceVtbl, DestroyImage)},
-    {"vkDestroyImageView", offsetof(DeviceVtbl, DestroyImageView)},
-    {"vkDestroyPipeline", offsetof(DeviceVtbl, DestroyPipeline)},
-    {"vkDestroyPipelineCache", offsetof(DeviceVtbl, DestroyPipelineCache)},
-    {"vkDestroyPipelineLayout", offsetof(DeviceVtbl, DestroyPipelineLayout)},
-    {"vkDestroyQueryPool", offsetof(DeviceVtbl, DestroyQueryPool)},
-    {"vkDestroyRenderPass", offsetof(DeviceVtbl, DestroyRenderPass)},
-    {"vkDestroySampler", offsetof(DeviceVtbl, DestroySampler)},
-    {"vkDestroySemaphore", offsetof(DeviceVtbl, DestroySemaphore)},
-    {"vkDestroyShaderModule", offsetof(DeviceVtbl, DestroyShaderModule)},
-    {"vkDestroySwapchainKHR", offsetof(DeviceVtbl, DestroySwapchainKHR)},
-    {"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)},
-    {"vkGetDeviceMemoryCommitment", offsetof(DeviceVtbl, GetDeviceMemoryCommitment)},
-    {"vkGetDeviceProcAddr", offsetof(DeviceVtbl, GetDeviceProcAddr)},
-    {"vkGetDeviceQueue", offsetof(DeviceVtbl, GetDeviceQueue)},
-    {"vkGetEventStatus", offsetof(DeviceVtbl, GetEventStatus)},
-    {"vkGetFenceStatus", offsetof(DeviceVtbl, GetFenceStatus)},
-    {"vkGetImageMemoryRequirements", offsetof(DeviceVtbl, GetImageMemoryRequirements)},
-    {"vkGetImageSparseMemoryRequirements", offsetof(DeviceVtbl, GetImageSparseMemoryRequirements)},
-    {"vkGetImageSubresourceLayout", offsetof(DeviceVtbl, GetImageSubresourceLayout)},
-    {"vkGetPipelineCacheData", offsetof(DeviceVtbl, GetPipelineCacheData)},
-    {"vkGetQueryPoolResults", offsetof(DeviceVtbl, GetQueryPoolResults)},
-    {"vkGetRenderAreaGranularity", offsetof(DeviceVtbl, GetRenderAreaGranularity)},
-    {"vkGetSwapchainImagesKHR", offsetof(DeviceVtbl, GetSwapchainImagesKHR)},
-    {"vkInvalidateMappedMemoryRanges", offsetof(DeviceVtbl, InvalidateMappedMemoryRanges)},
-    {"vkMapMemory", offsetof(DeviceVtbl, MapMemory)},
-    {"vkMergePipelineCaches", offsetof(DeviceVtbl, MergePipelineCaches)},
-    {"vkQueueBindSparse", offsetof(DeviceVtbl, QueueBindSparse)},
-    {"vkQueuePresentKHR", offsetof(DeviceVtbl, QueuePresentKHR)},
-    {"vkQueueSubmit", offsetof(DeviceVtbl, QueueSubmit)},
-    {"vkQueueWaitIdle", offsetof(DeviceVtbl, QueueWaitIdle)},
-    {"vkResetCommandBuffer", offsetof(DeviceVtbl, ResetCommandBuffer)},
-    {"vkResetCommandPool", offsetof(DeviceVtbl, ResetCommandPool)},
-    {"vkResetDescriptorPool", offsetof(DeviceVtbl, ResetDescriptorPool)},
-    {"vkResetEvent", offsetof(DeviceVtbl, ResetEvent)},
-    {"vkResetFences", offsetof(DeviceVtbl, ResetFences)},
-    {"vkSetEvent", offsetof(DeviceVtbl, SetEvent)},
-    {"vkUnmapMemory", offsetof(DeviceVtbl, UnmapMemory)},
-    {"vkUpdateDescriptorSets", offsetof(DeviceVtbl, UpdateDescriptorSets)},
-    {"vkWaitForFences", offsetof(DeviceVtbl, WaitForFences)},
-    // clang-format on
-};
-
-}  // namespace
-
-namespace vulkan {
-
-PFN_vkVoidFunction GetGlobalInstanceProcAddr(const char* name) {
-    const NameProcEntry* entry = FindProcEntry(kInstanceProcTbl, name);
-    if (entry)
-        return entry->proc;
-    // vkGetDeviceProcAddr must be available at the global/instance level for
-    // bootstrapping
-    if (strcmp(name, "vkGetDeviceProcAddr") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr);
-    return nullptr;
-}
-
-PFN_vkVoidFunction GetGlobalDeviceProcAddr(const char* name) {
-    const NameProcEntry* entry = FindProcEntry(kDeviceProcTbl, name);
-    if (entry)
-        return entry->proc;
-    return nullptr;
-}
-
-PFN_vkVoidFunction GetSpecificInstanceProcAddr(const InstanceVtbl* vtbl,
-                                               const char* name) {
-    size_t offset;
-    const NameOffsetEntry* entry = FindProcEntry(kInstanceOffsetTbl, name);
-    if (entry)
-        offset = entry->offset;
-    else
-        return nullptr;
-    const unsigned char* base = reinterpret_cast<const unsigned char*>(vtbl);
-    return *reinterpret_cast<PFN_vkVoidFunction*>(
-        const_cast<unsigned char*>(base) + offset);
-}
-
-PFN_vkVoidFunction GetSpecificDeviceProcAddr(const DeviceVtbl* vtbl,
-                                             const char* name) {
-    size_t offset;
-    const NameOffsetEntry* entry = FindProcEntry(kDeviceOffsetTbl, name);
-    if (entry)
-        offset = entry->offset;
-    else
-        return nullptr;
-    const unsigned char* base = reinterpret_cast<const unsigned char*>(vtbl);
-    return *reinterpret_cast<PFN_vkVoidFunction*>(
-        const_cast<unsigned char*>(base) + offset);
-}
-
-bool LoadInstanceVtbl(VkInstance instance,
-                      VkInstance instance_next,
-                      PFN_vkGetInstanceProcAddr get_proc_addr,
-                      InstanceVtbl& vtbl) {
-    bool success = true;
-    // clang-format off
-    vtbl.GetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(get_proc_addr(instance_next, "vkGetInstanceProcAddr"));
-    if (UNLIKELY(!vtbl.GetInstanceProcAddr)) {
-        ALOGE("missing instance proc: %s", "vkGetInstanceProcAddr");
-        success = false;
-    }
-    vtbl.CreateInstance = reinterpret_cast<PFN_vkCreateInstance>(get_proc_addr(instance, "vkCreateInstance"));
-    if (UNLIKELY(!vtbl.CreateInstance)) {
-        // This is allowed to fail as the driver doesn't have to return vkCreateInstance when given an instance
-    }
-    vtbl.DestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(get_proc_addr(instance, "vkDestroyInstance"));
-    if (UNLIKELY(!vtbl.DestroyInstance)) {
-        ALOGE("missing instance proc: %s", "vkDestroyInstance");
-        success = false;
-    }
-    vtbl.EnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(get_proc_addr(instance, "vkEnumeratePhysicalDevices"));
-    if (UNLIKELY(!vtbl.EnumeratePhysicalDevices)) {
-        ALOGE("missing instance proc: %s", "vkEnumeratePhysicalDevices");
-        success = false;
-    }
-    vtbl.GetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceProperties"));
-    if (UNLIKELY(!vtbl.GetPhysicalDeviceProperties)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceProperties");
-        success = false;
-    }
-    vtbl.GetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceQueueFamilyProperties"));
-    if (UNLIKELY(!vtbl.GetPhysicalDeviceQueueFamilyProperties)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceQueueFamilyProperties");
-        success = false;
-    }
-    vtbl.GetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceMemoryProperties"));
-    if (UNLIKELY(!vtbl.GetPhysicalDeviceMemoryProperties)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceMemoryProperties");
-        success = false;
-    }
-    vtbl.GetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(get_proc_addr(instance, "vkGetPhysicalDeviceFeatures"));
-    if (UNLIKELY(!vtbl.GetPhysicalDeviceFeatures)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceFeatures");
-        success = false;
-    }
-    vtbl.GetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceFormatProperties"));
-    if (UNLIKELY(!vtbl.GetPhysicalDeviceFormatProperties)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceFormatProperties");
-        success = false;
-    }
-    vtbl.GetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceImageFormatProperties"));
-    if (UNLIKELY(!vtbl.GetPhysicalDeviceImageFormatProperties)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceImageFormatProperties");
-        success = false;
-    }
-    vtbl.CreateDevice = reinterpret_cast<PFN_vkCreateDevice>(get_proc_addr(instance, "vkCreateDevice"));
-    if (UNLIKELY(!vtbl.CreateDevice)) {
-        ALOGE("missing instance proc: %s", "vkCreateDevice");
-        success = false;
-    }
-    vtbl.EnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(get_proc_addr(instance, "vkEnumerateDeviceLayerProperties"));
-    if (UNLIKELY(!vtbl.EnumerateDeviceLayerProperties)) {
-        ALOGE("missing instance proc: %s", "vkEnumerateDeviceLayerProperties");
-        success = false;
-    }
-    vtbl.EnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(get_proc_addr(instance, "vkEnumerateDeviceExtensionProperties"));
-    if (UNLIKELY(!vtbl.EnumerateDeviceExtensionProperties)) {
-        ALOGE("missing instance proc: %s", "vkEnumerateDeviceExtensionProperties");
-        success = false;
-    }
-    vtbl.GetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"));
-    if (UNLIKELY(!vtbl.GetPhysicalDeviceSparseImageFormatProperties)) {
-        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.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;
-}
-
-bool LoadDeviceVtbl(VkDevice device,
-                    VkDevice device_next,
-                    PFN_vkGetDeviceProcAddr get_proc_addr,
-                    DeviceVtbl& vtbl) {
-    bool success = true;
-    // clang-format off
-    vtbl.GetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(get_proc_addr(device_next, "vkGetDeviceProcAddr"));
-    if (UNLIKELY(!vtbl.GetDeviceProcAddr)) {
-        ALOGE("missing device proc: %s", "vkGetDeviceProcAddr");
-        success = false;
-    }
-    vtbl.DestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(get_proc_addr(device, "vkDestroyDevice"));
-    if (UNLIKELY(!vtbl.DestroyDevice)) {
-        ALOGE("missing device proc: %s", "vkDestroyDevice");
-        success = false;
-    }
-    vtbl.GetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(get_proc_addr(device, "vkGetDeviceQueue"));
-    if (UNLIKELY(!vtbl.GetDeviceQueue)) {
-        ALOGE("missing device proc: %s", "vkGetDeviceQueue");
-        success = false;
-    }
-    vtbl.QueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(get_proc_addr(device, "vkQueueSubmit"));
-    if (UNLIKELY(!vtbl.QueueSubmit)) {
-        ALOGE("missing device proc: %s", "vkQueueSubmit");
-        success = false;
-    }
-    vtbl.QueueWaitIdle = reinterpret_cast<PFN_vkQueueWaitIdle>(get_proc_addr(device, "vkQueueWaitIdle"));
-    if (UNLIKELY(!vtbl.QueueWaitIdle)) {
-        ALOGE("missing device proc: %s", "vkQueueWaitIdle");
-        success = false;
-    }
-    vtbl.DeviceWaitIdle = reinterpret_cast<PFN_vkDeviceWaitIdle>(get_proc_addr(device, "vkDeviceWaitIdle"));
-    if (UNLIKELY(!vtbl.DeviceWaitIdle)) {
-        ALOGE("missing device proc: %s", "vkDeviceWaitIdle");
-        success = false;
-    }
-    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"));
-    if (UNLIKELY(!vtbl.FreeMemory)) {
-        ALOGE("missing device proc: %s", "vkFreeMemory");
-        success = false;
-    }
-    vtbl.MapMemory = reinterpret_cast<PFN_vkMapMemory>(get_proc_addr(device, "vkMapMemory"));
-    if (UNLIKELY(!vtbl.MapMemory)) {
-        ALOGE("missing device proc: %s", "vkMapMemory");
-        success = false;
-    }
-    vtbl.UnmapMemory = reinterpret_cast<PFN_vkUnmapMemory>(get_proc_addr(device, "vkUnmapMemory"));
-    if (UNLIKELY(!vtbl.UnmapMemory)) {
-        ALOGE("missing device proc: %s", "vkUnmapMemory");
-        success = false;
-    }
-    vtbl.FlushMappedMemoryRanges = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(get_proc_addr(device, "vkFlushMappedMemoryRanges"));
-    if (UNLIKELY(!vtbl.FlushMappedMemoryRanges)) {
-        ALOGE("missing device proc: %s", "vkFlushMappedMemoryRanges");
-        success = false;
-    }
-    vtbl.InvalidateMappedMemoryRanges = reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(get_proc_addr(device, "vkInvalidateMappedMemoryRanges"));
-    if (UNLIKELY(!vtbl.InvalidateMappedMemoryRanges)) {
-        ALOGE("missing device proc: %s", "vkInvalidateMappedMemoryRanges");
-        success = false;
-    }
-    vtbl.GetDeviceMemoryCommitment = reinterpret_cast<PFN_vkGetDeviceMemoryCommitment>(get_proc_addr(device, "vkGetDeviceMemoryCommitment"));
-    if (UNLIKELY(!vtbl.GetDeviceMemoryCommitment)) {
-        ALOGE("missing device proc: %s", "vkGetDeviceMemoryCommitment");
-        success = false;
-    }
-    vtbl.GetBufferMemoryRequirements = reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(get_proc_addr(device, "vkGetBufferMemoryRequirements"));
-    if (UNLIKELY(!vtbl.GetBufferMemoryRequirements)) {
-        ALOGE("missing device proc: %s", "vkGetBufferMemoryRequirements");
-        success = false;
-    }
-    vtbl.BindBufferMemory = reinterpret_cast<PFN_vkBindBufferMemory>(get_proc_addr(device, "vkBindBufferMemory"));
-    if (UNLIKELY(!vtbl.BindBufferMemory)) {
-        ALOGE("missing device proc: %s", "vkBindBufferMemory");
-        success = false;
-    }
-    vtbl.GetImageMemoryRequirements = reinterpret_cast<PFN_vkGetImageMemoryRequirements>(get_proc_addr(device, "vkGetImageMemoryRequirements"));
-    if (UNLIKELY(!vtbl.GetImageMemoryRequirements)) {
-        ALOGE("missing device proc: %s", "vkGetImageMemoryRequirements");
-        success = false;
-    }
-    vtbl.BindImageMemory = reinterpret_cast<PFN_vkBindImageMemory>(get_proc_addr(device, "vkBindImageMemory"));
-    if (UNLIKELY(!vtbl.BindImageMemory)) {
-        ALOGE("missing device proc: %s", "vkBindImageMemory");
-        success = false;
-    }
-    vtbl.GetImageSparseMemoryRequirements = reinterpret_cast<PFN_vkGetImageSparseMemoryRequirements>(get_proc_addr(device, "vkGetImageSparseMemoryRequirements"));
-    if (UNLIKELY(!vtbl.GetImageSparseMemoryRequirements)) {
-        ALOGE("missing device proc: %s", "vkGetImageSparseMemoryRequirements");
-        success = false;
-    }
-    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"));
-    if (UNLIKELY(!vtbl.CreateFence)) {
-        ALOGE("missing device proc: %s", "vkCreateFence");
-        success = false;
-    }
-    vtbl.DestroyFence = reinterpret_cast<PFN_vkDestroyFence>(get_proc_addr(device, "vkDestroyFence"));
-    if (UNLIKELY(!vtbl.DestroyFence)) {
-        ALOGE("missing device proc: %s", "vkDestroyFence");
-        success = false;
-    }
-    vtbl.ResetFences = reinterpret_cast<PFN_vkResetFences>(get_proc_addr(device, "vkResetFences"));
-    if (UNLIKELY(!vtbl.ResetFences)) {
-        ALOGE("missing device proc: %s", "vkResetFences");
-        success = false;
-    }
-    vtbl.GetFenceStatus = reinterpret_cast<PFN_vkGetFenceStatus>(get_proc_addr(device, "vkGetFenceStatus"));
-    if (UNLIKELY(!vtbl.GetFenceStatus)) {
-        ALOGE("missing device proc: %s", "vkGetFenceStatus");
-        success = false;
-    }
-    vtbl.WaitForFences = reinterpret_cast<PFN_vkWaitForFences>(get_proc_addr(device, "vkWaitForFences"));
-    if (UNLIKELY(!vtbl.WaitForFences)) {
-        ALOGE("missing device proc: %s", "vkWaitForFences");
-        success = false;
-    }
-    vtbl.CreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(get_proc_addr(device, "vkCreateSemaphore"));
-    if (UNLIKELY(!vtbl.CreateSemaphore)) {
-        ALOGE("missing device proc: %s", "vkCreateSemaphore");
-        success = false;
-    }
-    vtbl.DestroySemaphore = reinterpret_cast<PFN_vkDestroySemaphore>(get_proc_addr(device, "vkDestroySemaphore"));
-    if (UNLIKELY(!vtbl.DestroySemaphore)) {
-        ALOGE("missing device proc: %s", "vkDestroySemaphore");
-        success = false;
-    }
-    vtbl.CreateEvent = reinterpret_cast<PFN_vkCreateEvent>(get_proc_addr(device, "vkCreateEvent"));
-    if (UNLIKELY(!vtbl.CreateEvent)) {
-        ALOGE("missing device proc: %s", "vkCreateEvent");
-        success = false;
-    }
-    vtbl.DestroyEvent = reinterpret_cast<PFN_vkDestroyEvent>(get_proc_addr(device, "vkDestroyEvent"));
-    if (UNLIKELY(!vtbl.DestroyEvent)) {
-        ALOGE("missing device proc: %s", "vkDestroyEvent");
-        success = false;
-    }
-    vtbl.GetEventStatus = reinterpret_cast<PFN_vkGetEventStatus>(get_proc_addr(device, "vkGetEventStatus"));
-    if (UNLIKELY(!vtbl.GetEventStatus)) {
-        ALOGE("missing device proc: %s", "vkGetEventStatus");
-        success = false;
-    }
-    vtbl.SetEvent = reinterpret_cast<PFN_vkSetEvent>(get_proc_addr(device, "vkSetEvent"));
-    if (UNLIKELY(!vtbl.SetEvent)) {
-        ALOGE("missing device proc: %s", "vkSetEvent");
-        success = false;
-    }
-    vtbl.ResetEvent = reinterpret_cast<PFN_vkResetEvent>(get_proc_addr(device, "vkResetEvent"));
-    if (UNLIKELY(!vtbl.ResetEvent)) {
-        ALOGE("missing device proc: %s", "vkResetEvent");
-        success = false;
-    }
-    vtbl.CreateQueryPool = reinterpret_cast<PFN_vkCreateQueryPool>(get_proc_addr(device, "vkCreateQueryPool"));
-    if (UNLIKELY(!vtbl.CreateQueryPool)) {
-        ALOGE("missing device proc: %s", "vkCreateQueryPool");
-        success = false;
-    }
-    vtbl.DestroyQueryPool = reinterpret_cast<PFN_vkDestroyQueryPool>(get_proc_addr(device, "vkDestroyQueryPool"));
-    if (UNLIKELY(!vtbl.DestroyQueryPool)) {
-        ALOGE("missing device proc: %s", "vkDestroyQueryPool");
-        success = false;
-    }
-    vtbl.GetQueryPoolResults = reinterpret_cast<PFN_vkGetQueryPoolResults>(get_proc_addr(device, "vkGetQueryPoolResults"));
-    if (UNLIKELY(!vtbl.GetQueryPoolResults)) {
-        ALOGE("missing device proc: %s", "vkGetQueryPoolResults");
-        success = false;
-    }
-    vtbl.CreateBuffer = reinterpret_cast<PFN_vkCreateBuffer>(get_proc_addr(device, "vkCreateBuffer"));
-    if (UNLIKELY(!vtbl.CreateBuffer)) {
-        ALOGE("missing device proc: %s", "vkCreateBuffer");
-        success = false;
-    }
-    vtbl.DestroyBuffer = reinterpret_cast<PFN_vkDestroyBuffer>(get_proc_addr(device, "vkDestroyBuffer"));
-    if (UNLIKELY(!vtbl.DestroyBuffer)) {
-        ALOGE("missing device proc: %s", "vkDestroyBuffer");
-        success = false;
-    }
-    vtbl.CreateBufferView = reinterpret_cast<PFN_vkCreateBufferView>(get_proc_addr(device, "vkCreateBufferView"));
-    if (UNLIKELY(!vtbl.CreateBufferView)) {
-        ALOGE("missing device proc: %s", "vkCreateBufferView");
-        success = false;
-    }
-    vtbl.DestroyBufferView = reinterpret_cast<PFN_vkDestroyBufferView>(get_proc_addr(device, "vkDestroyBufferView"));
-    if (UNLIKELY(!vtbl.DestroyBufferView)) {
-        ALOGE("missing device proc: %s", "vkDestroyBufferView");
-        success = false;
-    }
-    vtbl.CreateImage = reinterpret_cast<PFN_vkCreateImage>(get_proc_addr(device, "vkCreateImage"));
-    if (UNLIKELY(!vtbl.CreateImage)) {
-        ALOGE("missing device proc: %s", "vkCreateImage");
-        success = false;
-    }
-    vtbl.DestroyImage = reinterpret_cast<PFN_vkDestroyImage>(get_proc_addr(device, "vkDestroyImage"));
-    if (UNLIKELY(!vtbl.DestroyImage)) {
-        ALOGE("missing device proc: %s", "vkDestroyImage");
-        success = false;
-    }
-    vtbl.GetImageSubresourceLayout = reinterpret_cast<PFN_vkGetImageSubresourceLayout>(get_proc_addr(device, "vkGetImageSubresourceLayout"));
-    if (UNLIKELY(!vtbl.GetImageSubresourceLayout)) {
-        ALOGE("missing device proc: %s", "vkGetImageSubresourceLayout");
-        success = false;
-    }
-    vtbl.CreateImageView = reinterpret_cast<PFN_vkCreateImageView>(get_proc_addr(device, "vkCreateImageView"));
-    if (UNLIKELY(!vtbl.CreateImageView)) {
-        ALOGE("missing device proc: %s", "vkCreateImageView");
-        success = false;
-    }
-    vtbl.DestroyImageView = reinterpret_cast<PFN_vkDestroyImageView>(get_proc_addr(device, "vkDestroyImageView"));
-    if (UNLIKELY(!vtbl.DestroyImageView)) {
-        ALOGE("missing device proc: %s", "vkDestroyImageView");
-        success = false;
-    }
-    vtbl.CreateShaderModule = reinterpret_cast<PFN_vkCreateShaderModule>(get_proc_addr(device, "vkCreateShaderModule"));
-    if (UNLIKELY(!vtbl.CreateShaderModule)) {
-        ALOGE("missing device proc: %s", "vkCreateShaderModule");
-        success = false;
-    }
-    vtbl.DestroyShaderModule = reinterpret_cast<PFN_vkDestroyShaderModule>(get_proc_addr(device, "vkDestroyShaderModule"));
-    if (UNLIKELY(!vtbl.DestroyShaderModule)) {
-        ALOGE("missing device proc: %s", "vkDestroyShaderModule");
-        success = false;
-    }
-    vtbl.CreatePipelineCache = reinterpret_cast<PFN_vkCreatePipelineCache>(get_proc_addr(device, "vkCreatePipelineCache"));
-    if (UNLIKELY(!vtbl.CreatePipelineCache)) {
-        ALOGE("missing device proc: %s", "vkCreatePipelineCache");
-        success = false;
-    }
-    vtbl.DestroyPipelineCache = reinterpret_cast<PFN_vkDestroyPipelineCache>(get_proc_addr(device, "vkDestroyPipelineCache"));
-    if (UNLIKELY(!vtbl.DestroyPipelineCache)) {
-        ALOGE("missing device proc: %s", "vkDestroyPipelineCache");
-        success = false;
-    }
-    vtbl.GetPipelineCacheData = reinterpret_cast<PFN_vkGetPipelineCacheData>(get_proc_addr(device, "vkGetPipelineCacheData"));
-    if (UNLIKELY(!vtbl.GetPipelineCacheData)) {
-        ALOGE("missing device proc: %s", "vkGetPipelineCacheData");
-        success = false;
-    }
-    vtbl.MergePipelineCaches = reinterpret_cast<PFN_vkMergePipelineCaches>(get_proc_addr(device, "vkMergePipelineCaches"));
-    if (UNLIKELY(!vtbl.MergePipelineCaches)) {
-        ALOGE("missing device proc: %s", "vkMergePipelineCaches");
-        success = false;
-    }
-    vtbl.CreateGraphicsPipelines = reinterpret_cast<PFN_vkCreateGraphicsPipelines>(get_proc_addr(device, "vkCreateGraphicsPipelines"));
-    if (UNLIKELY(!vtbl.CreateGraphicsPipelines)) {
-        ALOGE("missing device proc: %s", "vkCreateGraphicsPipelines");
-        success = false;
-    }
-    vtbl.CreateComputePipelines = reinterpret_cast<PFN_vkCreateComputePipelines>(get_proc_addr(device, "vkCreateComputePipelines"));
-    if (UNLIKELY(!vtbl.CreateComputePipelines)) {
-        ALOGE("missing device proc: %s", "vkCreateComputePipelines");
-        success = false;
-    }
-    vtbl.DestroyPipeline = reinterpret_cast<PFN_vkDestroyPipeline>(get_proc_addr(device, "vkDestroyPipeline"));
-    if (UNLIKELY(!vtbl.DestroyPipeline)) {
-        ALOGE("missing device proc: %s", "vkDestroyPipeline");
-        success = false;
-    }
-    vtbl.CreatePipelineLayout = reinterpret_cast<PFN_vkCreatePipelineLayout>(get_proc_addr(device, "vkCreatePipelineLayout"));
-    if (UNLIKELY(!vtbl.CreatePipelineLayout)) {
-        ALOGE("missing device proc: %s", "vkCreatePipelineLayout");
-        success = false;
-    }
-    vtbl.DestroyPipelineLayout = reinterpret_cast<PFN_vkDestroyPipelineLayout>(get_proc_addr(device, "vkDestroyPipelineLayout"));
-    if (UNLIKELY(!vtbl.DestroyPipelineLayout)) {
-        ALOGE("missing device proc: %s", "vkDestroyPipelineLayout");
-        success = false;
-    }
-    vtbl.CreateSampler = reinterpret_cast<PFN_vkCreateSampler>(get_proc_addr(device, "vkCreateSampler"));
-    if (UNLIKELY(!vtbl.CreateSampler)) {
-        ALOGE("missing device proc: %s", "vkCreateSampler");
-        success = false;
-    }
-    vtbl.DestroySampler = reinterpret_cast<PFN_vkDestroySampler>(get_proc_addr(device, "vkDestroySampler"));
-    if (UNLIKELY(!vtbl.DestroySampler)) {
-        ALOGE("missing device proc: %s", "vkDestroySampler");
-        success = false;
-    }
-    vtbl.CreateDescriptorSetLayout = reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(get_proc_addr(device, "vkCreateDescriptorSetLayout"));
-    if (UNLIKELY(!vtbl.CreateDescriptorSetLayout)) {
-        ALOGE("missing device proc: %s", "vkCreateDescriptorSetLayout");
-        success = false;
-    }
-    vtbl.DestroyDescriptorSetLayout = reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(get_proc_addr(device, "vkDestroyDescriptorSetLayout"));
-    if (UNLIKELY(!vtbl.DestroyDescriptorSetLayout)) {
-        ALOGE("missing device proc: %s", "vkDestroyDescriptorSetLayout");
-        success = false;
-    }
-    vtbl.CreateDescriptorPool = reinterpret_cast<PFN_vkCreateDescriptorPool>(get_proc_addr(device, "vkCreateDescriptorPool"));
-    if (UNLIKELY(!vtbl.CreateDescriptorPool)) {
-        ALOGE("missing device proc: %s", "vkCreateDescriptorPool");
-        success = false;
-    }
-    vtbl.DestroyDescriptorPool = reinterpret_cast<PFN_vkDestroyDescriptorPool>(get_proc_addr(device, "vkDestroyDescriptorPool"));
-    if (UNLIKELY(!vtbl.DestroyDescriptorPool)) {
-        ALOGE("missing device proc: %s", "vkDestroyDescriptorPool");
-        success = false;
-    }
-    vtbl.ResetDescriptorPool = reinterpret_cast<PFN_vkResetDescriptorPool>(get_proc_addr(device, "vkResetDescriptorPool"));
-    if (UNLIKELY(!vtbl.ResetDescriptorPool)) {
-        ALOGE("missing device proc: %s", "vkResetDescriptorPool");
-        success = false;
-    }
-    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"));
-    if (UNLIKELY(!vtbl.FreeDescriptorSets)) {
-        ALOGE("missing device proc: %s", "vkFreeDescriptorSets");
-        success = false;
-    }
-    vtbl.UpdateDescriptorSets = reinterpret_cast<PFN_vkUpdateDescriptorSets>(get_proc_addr(device, "vkUpdateDescriptorSets"));
-    if (UNLIKELY(!vtbl.UpdateDescriptorSets)) {
-        ALOGE("missing device proc: %s", "vkUpdateDescriptorSets");
-        success = false;
-    }
-    vtbl.CreateFramebuffer = reinterpret_cast<PFN_vkCreateFramebuffer>(get_proc_addr(device, "vkCreateFramebuffer"));
-    if (UNLIKELY(!vtbl.CreateFramebuffer)) {
-        ALOGE("missing device proc: %s", "vkCreateFramebuffer");
-        success = false;
-    }
-    vtbl.DestroyFramebuffer = reinterpret_cast<PFN_vkDestroyFramebuffer>(get_proc_addr(device, "vkDestroyFramebuffer"));
-    if (UNLIKELY(!vtbl.DestroyFramebuffer)) {
-        ALOGE("missing device proc: %s", "vkDestroyFramebuffer");
-        success = false;
-    }
-    vtbl.CreateRenderPass = reinterpret_cast<PFN_vkCreateRenderPass>(get_proc_addr(device, "vkCreateRenderPass"));
-    if (UNLIKELY(!vtbl.CreateRenderPass)) {
-        ALOGE("missing device proc: %s", "vkCreateRenderPass");
-        success = false;
-    }
-    vtbl.DestroyRenderPass = reinterpret_cast<PFN_vkDestroyRenderPass>(get_proc_addr(device, "vkDestroyRenderPass"));
-    if (UNLIKELY(!vtbl.DestroyRenderPass)) {
-        ALOGE("missing device proc: %s", "vkDestroyRenderPass");
-        success = false;
-    }
-    vtbl.GetRenderAreaGranularity = reinterpret_cast<PFN_vkGetRenderAreaGranularity>(get_proc_addr(device, "vkGetRenderAreaGranularity"));
-    if (UNLIKELY(!vtbl.GetRenderAreaGranularity)) {
-        ALOGE("missing device proc: %s", "vkGetRenderAreaGranularity");
-        success = false;
-    }
-    vtbl.CreateCommandPool = reinterpret_cast<PFN_vkCreateCommandPool>(get_proc_addr(device, "vkCreateCommandPool"));
-    if (UNLIKELY(!vtbl.CreateCommandPool)) {
-        ALOGE("missing device proc: %s", "vkCreateCommandPool");
-        success = false;
-    }
-    vtbl.DestroyCommandPool = reinterpret_cast<PFN_vkDestroyCommandPool>(get_proc_addr(device, "vkDestroyCommandPool"));
-    if (UNLIKELY(!vtbl.DestroyCommandPool)) {
-        ALOGE("missing device proc: %s", "vkDestroyCommandPool");
-        success = false;
-    }
-    vtbl.ResetCommandPool = reinterpret_cast<PFN_vkResetCommandPool>(get_proc_addr(device, "vkResetCommandPool"));
-    if (UNLIKELY(!vtbl.ResetCommandPool)) {
-        ALOGE("missing device proc: %s", "vkResetCommandPool");
-        success = false;
-    }
-    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"));
-    if (UNLIKELY(!vtbl.FreeCommandBuffers)) {
-        ALOGE("missing device proc: %s", "vkFreeCommandBuffers");
-        success = false;
-    }
-    vtbl.BeginCommandBuffer = reinterpret_cast<PFN_vkBeginCommandBuffer>(get_proc_addr(device, "vkBeginCommandBuffer"));
-    if (UNLIKELY(!vtbl.BeginCommandBuffer)) {
-        ALOGE("missing device proc: %s", "vkBeginCommandBuffer");
-        success = false;
-    }
-    vtbl.EndCommandBuffer = reinterpret_cast<PFN_vkEndCommandBuffer>(get_proc_addr(device, "vkEndCommandBuffer"));
-    if (UNLIKELY(!vtbl.EndCommandBuffer)) {
-        ALOGE("missing device proc: %s", "vkEndCommandBuffer");
-        success = false;
-    }
-    vtbl.ResetCommandBuffer = reinterpret_cast<PFN_vkResetCommandBuffer>(get_proc_addr(device, "vkResetCommandBuffer"));
-    if (UNLIKELY(!vtbl.ResetCommandBuffer)) {
-        ALOGE("missing device proc: %s", "vkResetCommandBuffer");
-        success = false;
-    }
-    vtbl.CmdBindPipeline = reinterpret_cast<PFN_vkCmdBindPipeline>(get_proc_addr(device, "vkCmdBindPipeline"));
-    if (UNLIKELY(!vtbl.CmdBindPipeline)) {
-        ALOGE("missing device proc: %s", "vkCmdBindPipeline");
-        success = false;
-    }
-    vtbl.CmdSetViewport = reinterpret_cast<PFN_vkCmdSetViewport>(get_proc_addr(device, "vkCmdSetViewport"));
-    if (UNLIKELY(!vtbl.CmdSetViewport)) {
-        ALOGE("missing device proc: %s", "vkCmdSetViewport");
-        success = false;
-    }
-    vtbl.CmdSetScissor = reinterpret_cast<PFN_vkCmdSetScissor>(get_proc_addr(device, "vkCmdSetScissor"));
-    if (UNLIKELY(!vtbl.CmdSetScissor)) {
-        ALOGE("missing device proc: %s", "vkCmdSetScissor");
-        success = false;
-    }
-    vtbl.CmdSetLineWidth = reinterpret_cast<PFN_vkCmdSetLineWidth>(get_proc_addr(device, "vkCmdSetLineWidth"));
-    if (UNLIKELY(!vtbl.CmdSetLineWidth)) {
-        ALOGE("missing device proc: %s", "vkCmdSetLineWidth");
-        success = false;
-    }
-    vtbl.CmdSetDepthBias = reinterpret_cast<PFN_vkCmdSetDepthBias>(get_proc_addr(device, "vkCmdSetDepthBias"));
-    if (UNLIKELY(!vtbl.CmdSetDepthBias)) {
-        ALOGE("missing device proc: %s", "vkCmdSetDepthBias");
-        success = false;
-    }
-    vtbl.CmdSetBlendConstants = reinterpret_cast<PFN_vkCmdSetBlendConstants>(get_proc_addr(device, "vkCmdSetBlendConstants"));
-    if (UNLIKELY(!vtbl.CmdSetBlendConstants)) {
-        ALOGE("missing device proc: %s", "vkCmdSetBlendConstants");
-        success = false;
-    }
-    vtbl.CmdSetDepthBounds = reinterpret_cast<PFN_vkCmdSetDepthBounds>(get_proc_addr(device, "vkCmdSetDepthBounds"));
-    if (UNLIKELY(!vtbl.CmdSetDepthBounds)) {
-        ALOGE("missing device proc: %s", "vkCmdSetDepthBounds");
-        success = false;
-    }
-    vtbl.CmdSetStencilCompareMask = reinterpret_cast<PFN_vkCmdSetStencilCompareMask>(get_proc_addr(device, "vkCmdSetStencilCompareMask"));
-    if (UNLIKELY(!vtbl.CmdSetStencilCompareMask)) {
-        ALOGE("missing device proc: %s", "vkCmdSetStencilCompareMask");
-        success = false;
-    }
-    vtbl.CmdSetStencilWriteMask = reinterpret_cast<PFN_vkCmdSetStencilWriteMask>(get_proc_addr(device, "vkCmdSetStencilWriteMask"));
-    if (UNLIKELY(!vtbl.CmdSetStencilWriteMask)) {
-        ALOGE("missing device proc: %s", "vkCmdSetStencilWriteMask");
-        success = false;
-    }
-    vtbl.CmdSetStencilReference = reinterpret_cast<PFN_vkCmdSetStencilReference>(get_proc_addr(device, "vkCmdSetStencilReference"));
-    if (UNLIKELY(!vtbl.CmdSetStencilReference)) {
-        ALOGE("missing device proc: %s", "vkCmdSetStencilReference");
-        success = false;
-    }
-    vtbl.CmdBindDescriptorSets = reinterpret_cast<PFN_vkCmdBindDescriptorSets>(get_proc_addr(device, "vkCmdBindDescriptorSets"));
-    if (UNLIKELY(!vtbl.CmdBindDescriptorSets)) {
-        ALOGE("missing device proc: %s", "vkCmdBindDescriptorSets");
-        success = false;
-    }
-    vtbl.CmdBindIndexBuffer = reinterpret_cast<PFN_vkCmdBindIndexBuffer>(get_proc_addr(device, "vkCmdBindIndexBuffer"));
-    if (UNLIKELY(!vtbl.CmdBindIndexBuffer)) {
-        ALOGE("missing device proc: %s", "vkCmdBindIndexBuffer");
-        success = false;
-    }
-    vtbl.CmdBindVertexBuffers = reinterpret_cast<PFN_vkCmdBindVertexBuffers>(get_proc_addr(device, "vkCmdBindVertexBuffers"));
-    if (UNLIKELY(!vtbl.CmdBindVertexBuffers)) {
-        ALOGE("missing device proc: %s", "vkCmdBindVertexBuffers");
-        success = false;
-    }
-    vtbl.CmdDraw = reinterpret_cast<PFN_vkCmdDraw>(get_proc_addr(device, "vkCmdDraw"));
-    if (UNLIKELY(!vtbl.CmdDraw)) {
-        ALOGE("missing device proc: %s", "vkCmdDraw");
-        success = false;
-    }
-    vtbl.CmdDrawIndexed = reinterpret_cast<PFN_vkCmdDrawIndexed>(get_proc_addr(device, "vkCmdDrawIndexed"));
-    if (UNLIKELY(!vtbl.CmdDrawIndexed)) {
-        ALOGE("missing device proc: %s", "vkCmdDrawIndexed");
-        success = false;
-    }
-    vtbl.CmdDrawIndirect = reinterpret_cast<PFN_vkCmdDrawIndirect>(get_proc_addr(device, "vkCmdDrawIndirect"));
-    if (UNLIKELY(!vtbl.CmdDrawIndirect)) {
-        ALOGE("missing device proc: %s", "vkCmdDrawIndirect");
-        success = false;
-    }
-    vtbl.CmdDrawIndexedIndirect = reinterpret_cast<PFN_vkCmdDrawIndexedIndirect>(get_proc_addr(device, "vkCmdDrawIndexedIndirect"));
-    if (UNLIKELY(!vtbl.CmdDrawIndexedIndirect)) {
-        ALOGE("missing device proc: %s", "vkCmdDrawIndexedIndirect");
-        success = false;
-    }
-    vtbl.CmdDispatch = reinterpret_cast<PFN_vkCmdDispatch>(get_proc_addr(device, "vkCmdDispatch"));
-    if (UNLIKELY(!vtbl.CmdDispatch)) {
-        ALOGE("missing device proc: %s", "vkCmdDispatch");
-        success = false;
-    }
-    vtbl.CmdDispatchIndirect = reinterpret_cast<PFN_vkCmdDispatchIndirect>(get_proc_addr(device, "vkCmdDispatchIndirect"));
-    if (UNLIKELY(!vtbl.CmdDispatchIndirect)) {
-        ALOGE("missing device proc: %s", "vkCmdDispatchIndirect");
-        success = false;
-    }
-    vtbl.CmdCopyBuffer = reinterpret_cast<PFN_vkCmdCopyBuffer>(get_proc_addr(device, "vkCmdCopyBuffer"));
-    if (UNLIKELY(!vtbl.CmdCopyBuffer)) {
-        ALOGE("missing device proc: %s", "vkCmdCopyBuffer");
-        success = false;
-    }
-    vtbl.CmdCopyImage = reinterpret_cast<PFN_vkCmdCopyImage>(get_proc_addr(device, "vkCmdCopyImage"));
-    if (UNLIKELY(!vtbl.CmdCopyImage)) {
-        ALOGE("missing device proc: %s", "vkCmdCopyImage");
-        success = false;
-    }
-    vtbl.CmdBlitImage = reinterpret_cast<PFN_vkCmdBlitImage>(get_proc_addr(device, "vkCmdBlitImage"));
-    if (UNLIKELY(!vtbl.CmdBlitImage)) {
-        ALOGE("missing device proc: %s", "vkCmdBlitImage");
-        success = false;
-    }
-    vtbl.CmdCopyBufferToImage = reinterpret_cast<PFN_vkCmdCopyBufferToImage>(get_proc_addr(device, "vkCmdCopyBufferToImage"));
-    if (UNLIKELY(!vtbl.CmdCopyBufferToImage)) {
-        ALOGE("missing device proc: %s", "vkCmdCopyBufferToImage");
-        success = false;
-    }
-    vtbl.CmdCopyImageToBuffer = reinterpret_cast<PFN_vkCmdCopyImageToBuffer>(get_proc_addr(device, "vkCmdCopyImageToBuffer"));
-    if (UNLIKELY(!vtbl.CmdCopyImageToBuffer)) {
-        ALOGE("missing device proc: %s", "vkCmdCopyImageToBuffer");
-        success = false;
-    }
-    vtbl.CmdUpdateBuffer = reinterpret_cast<PFN_vkCmdUpdateBuffer>(get_proc_addr(device, "vkCmdUpdateBuffer"));
-    if (UNLIKELY(!vtbl.CmdUpdateBuffer)) {
-        ALOGE("missing device proc: %s", "vkCmdUpdateBuffer");
-        success = false;
-    }
-    vtbl.CmdFillBuffer = reinterpret_cast<PFN_vkCmdFillBuffer>(get_proc_addr(device, "vkCmdFillBuffer"));
-    if (UNLIKELY(!vtbl.CmdFillBuffer)) {
-        ALOGE("missing device proc: %s", "vkCmdFillBuffer");
-        success = false;
-    }
-    vtbl.CmdClearColorImage = reinterpret_cast<PFN_vkCmdClearColorImage>(get_proc_addr(device, "vkCmdClearColorImage"));
-    if (UNLIKELY(!vtbl.CmdClearColorImage)) {
-        ALOGE("missing device proc: %s", "vkCmdClearColorImage");
-        success = false;
-    }
-    vtbl.CmdClearDepthStencilImage = reinterpret_cast<PFN_vkCmdClearDepthStencilImage>(get_proc_addr(device, "vkCmdClearDepthStencilImage"));
-    if (UNLIKELY(!vtbl.CmdClearDepthStencilImage)) {
-        ALOGE("missing device proc: %s", "vkCmdClearDepthStencilImage");
-        success = false;
-    }
-    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"));
-    if (UNLIKELY(!vtbl.CmdResolveImage)) {
-        ALOGE("missing device proc: %s", "vkCmdResolveImage");
-        success = false;
-    }
-    vtbl.CmdSetEvent = reinterpret_cast<PFN_vkCmdSetEvent>(get_proc_addr(device, "vkCmdSetEvent"));
-    if (UNLIKELY(!vtbl.CmdSetEvent)) {
-        ALOGE("missing device proc: %s", "vkCmdSetEvent");
-        success = false;
-    }
-    vtbl.CmdResetEvent = reinterpret_cast<PFN_vkCmdResetEvent>(get_proc_addr(device, "vkCmdResetEvent"));
-    if (UNLIKELY(!vtbl.CmdResetEvent)) {
-        ALOGE("missing device proc: %s", "vkCmdResetEvent");
-        success = false;
-    }
-    vtbl.CmdWaitEvents = reinterpret_cast<PFN_vkCmdWaitEvents>(get_proc_addr(device, "vkCmdWaitEvents"));
-    if (UNLIKELY(!vtbl.CmdWaitEvents)) {
-        ALOGE("missing device proc: %s", "vkCmdWaitEvents");
-        success = false;
-    }
-    vtbl.CmdPipelineBarrier = reinterpret_cast<PFN_vkCmdPipelineBarrier>(get_proc_addr(device, "vkCmdPipelineBarrier"));
-    if (UNLIKELY(!vtbl.CmdPipelineBarrier)) {
-        ALOGE("missing device proc: %s", "vkCmdPipelineBarrier");
-        success = false;
-    }
-    vtbl.CmdBeginQuery = reinterpret_cast<PFN_vkCmdBeginQuery>(get_proc_addr(device, "vkCmdBeginQuery"));
-    if (UNLIKELY(!vtbl.CmdBeginQuery)) {
-        ALOGE("missing device proc: %s", "vkCmdBeginQuery");
-        success = false;
-    }
-    vtbl.CmdEndQuery = reinterpret_cast<PFN_vkCmdEndQuery>(get_proc_addr(device, "vkCmdEndQuery"));
-    if (UNLIKELY(!vtbl.CmdEndQuery)) {
-        ALOGE("missing device proc: %s", "vkCmdEndQuery");
-        success = false;
-    }
-    vtbl.CmdResetQueryPool = reinterpret_cast<PFN_vkCmdResetQueryPool>(get_proc_addr(device, "vkCmdResetQueryPool"));
-    if (UNLIKELY(!vtbl.CmdResetQueryPool)) {
-        ALOGE("missing device proc: %s", "vkCmdResetQueryPool");
-        success = false;
-    }
-    vtbl.CmdWriteTimestamp = reinterpret_cast<PFN_vkCmdWriteTimestamp>(get_proc_addr(device, "vkCmdWriteTimestamp"));
-    if (UNLIKELY(!vtbl.CmdWriteTimestamp)) {
-        ALOGE("missing device proc: %s", "vkCmdWriteTimestamp");
-        success = false;
-    }
-    vtbl.CmdCopyQueryPoolResults = reinterpret_cast<PFN_vkCmdCopyQueryPoolResults>(get_proc_addr(device, "vkCmdCopyQueryPoolResults"));
-    if (UNLIKELY(!vtbl.CmdCopyQueryPoolResults)) {
-        ALOGE("missing device proc: %s", "vkCmdCopyQueryPoolResults");
-        success = false;
-    }
-    vtbl.CmdPushConstants = reinterpret_cast<PFN_vkCmdPushConstants>(get_proc_addr(device, "vkCmdPushConstants"));
-    if (UNLIKELY(!vtbl.CmdPushConstants)) {
-        ALOGE("missing device proc: %s", "vkCmdPushConstants");
-        success = false;
-    }
-    vtbl.CmdBeginRenderPass = reinterpret_cast<PFN_vkCmdBeginRenderPass>(get_proc_addr(device, "vkCmdBeginRenderPass"));
-    if (UNLIKELY(!vtbl.CmdBeginRenderPass)) {
-        ALOGE("missing device proc: %s", "vkCmdBeginRenderPass");
-        success = false;
-    }
-    vtbl.CmdNextSubpass = reinterpret_cast<PFN_vkCmdNextSubpass>(get_proc_addr(device, "vkCmdNextSubpass"));
-    if (UNLIKELY(!vtbl.CmdNextSubpass)) {
-        ALOGE("missing device proc: %s", "vkCmdNextSubpass");
-        success = false;
-    }
-    vtbl.CmdEndRenderPass = reinterpret_cast<PFN_vkCmdEndRenderPass>(get_proc_addr(device, "vkCmdEndRenderPass"));
-    if (UNLIKELY(!vtbl.CmdEndRenderPass)) {
-        ALOGE("missing device proc: %s", "vkCmdEndRenderPass");
-        success = false;
-    }
-    vtbl.CmdExecuteCommands = reinterpret_cast<PFN_vkCmdExecuteCommands>(get_proc_addr(device, "vkCmdExecuteCommands"));
-    if (UNLIKELY(!vtbl.CmdExecuteCommands)) {
-        ALOGE("missing device proc: %s", "vkCmdExecuteCommands");
-        success = false;
-    }
-    vtbl.CreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(get_proc_addr(device, "vkCreateSwapchainKHR"));
-    if (UNLIKELY(!vtbl.CreateSwapchainKHR)) {
-        ALOGE("missing device proc: %s", "vkCreateSwapchainKHR");
-        success = false;
-    }
-    vtbl.DestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(get_proc_addr(device, "vkDestroySwapchainKHR"));
-    if (UNLIKELY(!vtbl.DestroySwapchainKHR)) {
-        ALOGE("missing device proc: %s", "vkDestroySwapchainKHR");
-        success = false;
-    }
-    vtbl.GetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(get_proc_addr(device, "vkGetSwapchainImagesKHR"));
-    if (UNLIKELY(!vtbl.GetSwapchainImagesKHR)) {
-        ALOGE("missing device proc: %s", "vkGetSwapchainImagesKHR");
-        success = false;
-    }
-    vtbl.AcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(get_proc_addr(device, "vkAcquireNextImageKHR"));
-    if (UNLIKELY(!vtbl.AcquireNextImageKHR)) {
-        ALOGE("missing device proc: %s", "vkAcquireNextImageKHR");
-        success = false;
-    }
-    vtbl.QueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(get_proc_addr(device, "vkQueuePresentKHR"));
-    if (UNLIKELY(!vtbl.QueuePresentKHR)) {
-        ALOGE("missing device proc: %s", "vkQueuePresentKHR");
-        success = false;
-    }
-    vtbl.GetSwapchainGrallocUsageANDROID = reinterpret_cast<PFN_vkGetSwapchainGrallocUsageANDROID>(get_proc_addr(device, "vkGetSwapchainGrallocUsageANDROID"));
-    if (UNLIKELY(!vtbl.GetSwapchainGrallocUsageANDROID)) {
-        // TODO(jessehall): temporarily make this optional, until drivers have been updated
-        // ALOGE("missing device proc: %s", "vkGetSwapchainGrallocUsageANDROID");
-        ALOGW("missing device proc: %s", "vkGetSwapchainGrallocUsageANDROID");
-        // success = false;
-    }
-    vtbl.AcquireImageANDROID = reinterpret_cast<PFN_vkAcquireImageANDROID>(get_proc_addr(device, "vkAcquireImageANDROID"));
-    if (UNLIKELY(!vtbl.AcquireImageANDROID)) {
-        // TODO(jessehall): temporarily make this optional, until drivers have been updated
-        // ALOGE("missing device proc: %s", "vkImportNativeFenceANDROID");
-        ALOGW("missing device proc: %s", "vkAcquireImageANDROID");
-        // success = false;
-    }
-    vtbl.QueueSignalReleaseImageANDROID = reinterpret_cast<PFN_vkQueueSignalReleaseImageANDROID>(get_proc_addr(device, "vkQueueSignalReleaseImageANDROID"));
-    if (UNLIKELY(!vtbl.QueueSignalReleaseImageANDROID)) {
-        // TODO(jessehall): temporarily make this optional, until drivers have been updated
-        // ALOGE("missing device proc: %s", "vkQueueSignalReleaseImageANDROID");
-        ALOGW("missing device proc: %s", "vkQueueSignalReleaseImageANDROID");
-        // success = false;
-    }
-    // TODO(jessehall): these are deprecated; remove when drivers have been updated
-    vtbl.ImportNativeFenceANDROID = reinterpret_cast<PFN_vkImportNativeFenceANDROID>(get_proc_addr(device, "vkImportNativeFenceANDROID"));
-    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_ANDROID_native_buffer commands");
-        success = false;
-    }
-    // clang-format on
-    return success;
-}
-
-}  // namespace vulkan
diff --git a/vulkan/libvulkan/get_proc_addr.cpp.tmpl b/vulkan/libvulkan/get_proc_addr.cpp.tmpl
deleted file mode 100644
index 423dea4..0000000
--- a/vulkan/libvulkan/get_proc_addr.cpp.tmpl
+++ /dev/null
@@ -1,309 +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.
- */}}
-
-{{Include "../api/templates/vulkan_common.tmpl"}}
-{{Global "clang-format" (Strings "clang-format" "-style=file")}}
-{{Macro "DefineGlobals" $}}
-{{$ | Macro "get_proc_addr.cpp" | Format (Global "clang-format") | Write "get_proc_addr.cpp"}}
-
-
-{{/*
--------------------------------------------------------------------------------
-  Entry point
--------------------------------------------------------------------------------
-*/}}
-{{define "get_proc_addr.cpp"}}
-/*
- * 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.
- */
-¶
-// This file is generated. Do not edit manually!
-// To regenerate: $ apic template ../api/vulkan.api get_proc_addr.cpp.tmpl
-// Requires apic from https://android.googlesource.com/platform/tools/gpu/.
-¶
-#include <algorithm>
-#include <log/log.h>
-#include "loader.h"
-using namespace vulkan;
-¶
-#define UNLIKELY(expr) __builtin_expect((expr), 0)
-¶
-namespace {
-¶
-struct NameProcEntry {
-    const char* name;
-    PFN_vkVoidFunction proc;
-};
-¶
-struct NameOffsetEntry {
-    const char* name;
-    size_t offset;
-};
-¶
-template <typename TEntry, size_t N>
-const TEntry* FindProcEntry(const TEntry (&table)[N], const char* name) {
-    auto entry = std::lower_bound(
-        table, table + N, name,
-        [](const TEntry& e, const char* n) { return strcmp(e.name, n) < 0; });
-    if (entry != (table + N) && strcmp(entry->name, name) == 0)
-        return entry;
-    return nullptr;
-}
-¶
-const NameProcEntry kInstanceProcTbl[] = {«
-  // clang-format off
-  {{range $f := SortBy (AllCommands $) "FunctionName"}}
-    {{if and (Macro "IsDispatched" $f) (eq (Macro "Vtbl" $f) "Instance")}}
-      {"{{Macro "FunctionName" $f}}", reinterpret_cast<PFN_vkVoidFunction>({{Macro "FunctionName" $f}})},
-    {{end}}
-  {{end}}
-  // clang-format on
-»};
-¶
-const NameProcEntry kDeviceProcTbl[] = {«
-  // clang-format off
-  {{range $f := SortBy (AllCommands $) "FunctionName"}}
-    {{if and (Macro "IsDispatched" $f) (eq (Macro "Vtbl" $f) "Device")}}
-      {"{{Macro "FunctionName" $f}}", reinterpret_cast<PFN_vkVoidFunction>({{Macro "FunctionName" $f}})},
-    {{end}}
-  {{end}}
-  // clang-format on
-»};
-¶
-const NameOffsetEntry kInstanceOffsetTbl[] = {«
-  // clang-format off
-  {{range $f := SortBy (AllCommands $) "FunctionName"}}
-    {{if and (Macro "IsDispatched" $f) (eq (Macro "Vtbl" $f) "Instance")}}
-      {"{{Macro "FunctionName" $f}}", offsetof(InstanceVtbl, {{TrimPrefix "vk" (Macro "FunctionName" $f)}})},
-    {{end}}
-  {{end}}
-  // clang-format on
-»};
-¶
-const NameOffsetEntry kDeviceOffsetTbl[] = {«
-  // clang-format off
-  {{range $f := SortBy (AllCommands $) "FunctionName"}}
-    {{if and (Macro "IsDispatched" $f) (eq (Macro "Vtbl" $f) "Device")}}
-      {"{{Macro "FunctionName" $f}}", offsetof(DeviceVtbl, {{TrimPrefix "vk" (Macro "FunctionName" $f)}})},
-    {{end}}
-  {{end}}
-  // clang-format on
-»};
-¶
-} // namespace
-¶
-namespace vulkan {
-¶
-PFN_vkVoidFunction GetGlobalInstanceProcAddr(const char* name) {
-    const NameProcEntry* entry = FindProcEntry(kInstanceProcTbl, name);
-    if (entry)
-        return entry->proc;
-    // vkGetDeviceProcAddr must be available at the global/instance level for bootstrapping
-    if (strcmp(name, "vkGetDeviceProcAddr") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr);
-    return nullptr;
-}
-¶
-PFN_vkVoidFunction GetGlobalDeviceProcAddr(const char* name) {
-    const NameProcEntry* entry = FindProcEntry(kDeviceProcTbl, name);
-    if (entry)
-        return entry->proc;
-    return nullptr;
-}
-¶
-PFN_vkVoidFunction GetSpecificInstanceProcAddr(const InstanceVtbl* vtbl,
-                                               const char* name) {
-    size_t offset;
-    const NameOffsetEntry* entry = FindProcEntry(kInstanceOffsetTbl, name);
-    if (entry)
-        offset = entry->offset;
-    else
-        return nullptr;
-    const unsigned char* base = reinterpret_cast<const unsigned char*>(vtbl);
-    return *reinterpret_cast<PFN_vkVoidFunction*>(
-        const_cast<unsigned char*>(base) + offset);
-}
-¶
-PFN_vkVoidFunction GetSpecificDeviceProcAddr(const DeviceVtbl* vtbl,
-                                             const char* name) {
-    size_t offset;
-    const NameOffsetEntry* entry = FindProcEntry(kDeviceOffsetTbl, name);
-    if (entry)
-        offset = entry->offset;
-    else
-        return nullptr;
-    const unsigned char* base = reinterpret_cast<const unsigned char*>(vtbl);
-    return *reinterpret_cast<PFN_vkVoidFunction*>(
-        const_cast<unsigned char*>(base) + offset);
-}
-¶
-bool LoadInstanceVtbl(VkInstance instance,
-                      VkInstance instance_next,
-                      PFN_vkGetInstanceProcAddr get_proc_addr,
-                      InstanceVtbl& vtbl) {«
-    bool success = true;
-    // clang-format off
-    vtbl.GetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(get_proc_addr(instance_next, "vkGetInstanceProcAddr"));
-    if (UNLIKELY(!vtbl.GetInstanceProcAddr)) {
-        ALOGE("missing instance proc: %s", "vkGetInstanceProcAddr");
-        success = false;
-    }
-    vtbl.CreateInstance = reinterpret_cast<PFN_vkCreateInstance>(get_proc_addr(instance, "vkCreateInstance"));
-    if (UNLIKELY(!vtbl.CreateInstance)) {
-        // This is allowed to fail as the driver doesn't have to return vkCreateInstance when given an instance
-    }
-    {{range $f := AllCommands $}}
-      {{if eq (Macro "Vtbl" $f) "Instance"}}
-        {{if not (eq (Macro "FunctionName" $f) "vkGetInstanceProcAddr")}}
-          {{if not (GetAnnotation $f "extension")}}
-    vtbl.{{TrimPrefix "vk" (Macro "FunctionName" $f)}} = §
-        reinterpret_cast<{{Macro "FunctionPtrName" $f}}>(§
-            get_proc_addr(instance, "{{Macro "FunctionName" $f}}"));
-    if (UNLIKELY(!vtbl.{{TrimPrefix "vk" (Macro "FunctionName" $f)}})) {
-        ALOGE("missing instance proc: %s", "{{Macro "FunctionName" $f}}");
-        success = false;
-    }
-          {{end}}
-        {{end}}
-      {{end}}
-    {{end}}
-    {{range $f := AllCommands $}}
-      {{if eq (Macro "Vtbl" $f) "Instance"}}
-        {{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}}"));
-        {{end}}
-      {{end}}
-    {{end}}
-    // clang-format on
-    return success;
-»}
-¶
-bool LoadDeviceVtbl(VkDevice device,
-                    VkDevice device_next,
-                    PFN_vkGetDeviceProcAddr get_proc_addr,
-                    DeviceVtbl& vtbl) {«
-    bool success = true;
-    // clang-format off
-    vtbl.GetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(get_proc_addr(device_next, "vkGetDeviceProcAddr"));
-    if (UNLIKELY(!vtbl.GetDeviceProcAddr)) {
-        ALOGE("missing device proc: %s", "vkGetDeviceProcAddr");
-        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 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}}"));
-    if (UNLIKELY(!vtbl.{{TrimPrefix "vk" (Macro "FunctionName" $f)}})) {
-        ALOGE("missing device proc: %s", "{{Macro "FunctionName" $f}}");
-        success = false;
-    }
-        {{end}}
-      {{end}}
-    {{end}}
-    vtbl.GetSwapchainGrallocUsageANDROID = reinterpret_cast<PFN_vkGetSwapchainGrallocUsageANDROID>(get_proc_addr(device, "vkGetSwapchainGrallocUsageANDROID"));
-    if (UNLIKELY(!vtbl.GetSwapchainGrallocUsageANDROID)) {
-        // TODO(jessehall): temporarily make this optional, until drivers have been updated
-        // ALOGE("missing device proc: %s", "vkGetSwapchainGrallocUsageANDROID");
-        ALOGW("missing device proc: %s", "vkGetSwapchainGrallocUsageANDROID");
-        // success = false;
-    }
-    vtbl.AcquireImageANDROID = reinterpret_cast<PFN_vkAcquireImageANDROID>(get_proc_addr(device, "vkAcquireImageANDROID"));
-    if (UNLIKELY(!vtbl.AcquireImageANDROID)) {
-        // TODO(jessehall): temporarily make this optional, until drivers have been updated
-        // ALOGE("missing device proc: %s", "vkImportNativeFenceANDROID");
-        ALOGW("missing device proc: %s", "vkAcquireImageANDROID");
-        // success = false;
-    }
-    vtbl.QueueSignalReleaseImageANDROID = reinterpret_cast<PFN_vkQueueSignalReleaseImageANDROID>(get_proc_addr(device, "vkQueueSignalReleaseImageANDROID"));
-    if (UNLIKELY(!vtbl.QueueSignalReleaseImageANDROID)) {
-        // TODO(jessehall): temporarily make this optional, until drivers have been updated
-        // ALOGE("missing device proc: %s", "vkQueueSignalReleaseImageANDROID");
-        ALOGW("missing device proc: %s", "vkQueueSignalReleaseImageANDROID");
-        // success = false;
-    }
-    // TODO(jessehall): these are deprecated; remove when drivers have been updated
-    vtbl.ImportNativeFenceANDROID = reinterpret_cast<PFN_vkImportNativeFenceANDROID>(get_proc_addr(device, "vkImportNativeFenceANDROID"));
-    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_ANDROID_native_buffer commands");
-        success = false;
-    }
-    // clang-format on
-    return success;
-»}
-¶
-} // 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_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}}
-
-{{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/layers_extensions.cpp b/vulkan/libvulkan/layers_extensions.cpp
new file mode 100644
index 0000000..e56cdea
--- /dev/null
+++ b/vulkan/libvulkan/layers_extensions.cpp
@@ -0,0 +1,268 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#define LOG_NDEBUG 0
+
+#include "loader.h"
+#include <alloca.h>
+#include <dirent.h>
+#include <dlfcn.h>
+#include <mutex>
+#include <sys/prctl.h>
+#include <string>
+#include <string.h>
+#include <vector>
+#include <log/log.h>
+#include <vulkan/vulkan_loader_data.h>
+
+using namespace vulkan;
+
+namespace vulkan {
+struct Layer {
+    VkLayerProperties properties;
+    size_t library_idx;
+    std::vector<VkExtensionProperties> extensions;
+};
+}  // namespace vulkan
+
+namespace {
+
+std::mutex g_library_mutex;
+struct LayerLibrary {
+    std::string path;
+    void* dlhandle;
+    size_t refcount;
+};
+std::vector<LayerLibrary> g_layer_libraries;
+std::vector<Layer> g_layers;
+
+void AddLayerLibrary(const std::string& path) {
+    ALOGV("examining layer library '%s'", path.c_str());
+
+    void* dlhandle = dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL);
+    if (!dlhandle) {
+        ALOGW("failed to load layer library '%s': %s", path.c_str(), dlerror());
+        return;
+    }
+
+    PFN_vkEnumerateInstanceLayerProperties enumerate_layer_properties =
+        reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
+            dlsym(dlhandle, "vkEnumerateInstanceLayerProperties"));
+    if (!enumerate_layer_properties) {
+        ALOGW(
+            "failed to find vkEnumerateInstanceLayerProperties in library "
+            "'%s': %s",
+            path.c_str(), dlerror());
+        dlclose(dlhandle);
+        return;
+    }
+    PFN_vkEnumerateInstanceExtensionProperties enumerate_extension_properties =
+        reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(
+            dlsym(dlhandle, "vkEnumerateInstanceExtensionProperties"));
+    if (!enumerate_extension_properties) {
+        ALOGW(
+            "failed to find vkEnumerateInstanceExtensionProperties in library "
+            "'%s': %s",
+            path.c_str(), dlerror());
+        dlclose(dlhandle);
+        return;
+    }
+
+    uint32_t layer_count;
+    VkResult result = enumerate_layer_properties(&layer_count, nullptr);
+    if (result != VK_SUCCESS) {
+        ALOGW("vkEnumerateInstanceLayerProperties failed for library '%s': %d",
+              path.c_str(), result);
+        dlclose(dlhandle);
+        return;
+    }
+    VkLayerProperties* properties = static_cast<VkLayerProperties*>(
+        alloca(layer_count * sizeof(VkLayerProperties)));
+    result = enumerate_layer_properties(&layer_count, properties);
+    if (result != VK_SUCCESS) {
+        ALOGW("vkEnumerateInstanceLayerProperties failed for library '%s': %d",
+              path.c_str(), result);
+        dlclose(dlhandle);
+        return;
+    }
+
+    size_t library_idx = g_layer_libraries.size();
+    g_layers.reserve(g_layers.size() + layer_count);
+    for (size_t i = 0; i < layer_count; i++) {
+        Layer layer;
+        layer.properties = properties[i];
+        layer.library_idx = library_idx;
+
+        uint32_t count;
+        result = enumerate_extension_properties(properties[i].layerName, &count,
+                                                nullptr);
+        if (result != VK_SUCCESS) {
+            ALOGW(
+                "vkEnumerateInstanceExtensionProperties(%s) failed for library "
+                "'%s': %d",
+                properties[i].layerName, path.c_str(), result);
+            g_layers.resize(g_layers.size() - (i + 1));
+            dlclose(dlhandle);
+            return;
+        }
+        layer.extensions.resize(count);
+        result = enumerate_extension_properties(properties[i].layerName, &count,
+                                                layer.extensions.data());
+        if (result != VK_SUCCESS) {
+            ALOGW(
+                "vkEnumerateInstanceExtensionProperties(%s) failed for library "
+                "'%s': %d",
+                properties[i].layerName, path.c_str(), result);
+            g_layers.resize(g_layers.size() - (i + 1));
+            dlclose(dlhandle);
+            return;
+        }
+
+        g_layers.push_back(layer);
+        ALOGV("found layer '%s'", properties[i].layerName);
+    }
+
+    dlclose(dlhandle);
+
+    g_layer_libraries.push_back(LayerLibrary{path, nullptr, 0});
+}
+
+void DiscoverLayersInDirectory(const std::string& dir_path) {
+    ALOGV("looking for layers in '%s'", dir_path.c_str());
+
+    DIR* directory = opendir(dir_path.c_str());
+    if (!directory) {
+        int err = errno;
+        ALOGV_IF(err != ENOENT, "failed to open layer directory '%s': %s (%d)",
+                 dir_path.c_str(), strerror(err), err);
+        return;
+    }
+
+    std::string path;
+    path.reserve(dir_path.size() + 20);
+    path.append(dir_path);
+    path.append("/");
+
+    struct dirent* entry;
+    while ((entry = readdir(directory))) {
+        size_t libname_len = strlen(entry->d_name);
+        if (strncmp(entry->d_name, "libVKLayer", 10) != 0 ||
+            strncmp(entry->d_name + libname_len - 3, ".so", 3) != 0)
+            continue;
+        path.append(entry->d_name);
+        AddLayerLibrary(path);
+        path.resize(dir_path.size() + 1);
+    }
+
+    closedir(directory);
+}
+
+void* GetLayerGetProcAddr(const Layer& layer,
+                          const char* gpa_name,
+                          size_t gpa_name_len) {
+    const LayerLibrary& library = g_layer_libraries[layer.library_idx];
+    void* gpa;
+    size_t layer_name_len = std::max(2u, strlen(layer.properties.layerName));
+    char* name = static_cast<char*>(alloca(layer_name_len + gpa_name_len + 1));
+    strcpy(name, layer.properties.layerName);
+    strcpy(name + layer_name_len, gpa_name);
+    if (!(gpa = dlsym(library.dlhandle, name))) {
+        strcpy(name, "vk");
+        strcpy(name + 2, gpa_name);
+        gpa = dlsym(library.dlhandle, name);
+    }
+    return gpa;
+}
+
+}  // anonymous namespace
+
+namespace vulkan {
+
+void DiscoverLayers() {
+    if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0))
+        DiscoverLayersInDirectory("/data/local/debug/vulkan");
+    if (!LoaderData::GetInstance().layer_path.empty())
+        DiscoverLayersInDirectory(LoaderData::GetInstance().layer_path.c_str());
+}
+
+uint32_t EnumerateLayers(uint32_t count, VkLayerProperties* properties) {
+    uint32_t n = std::min(count, g_layers.size());
+    for (uint32_t i = 0; i < n; i++) {
+        properties[i] = g_layers[i].properties;
+    }
+    return g_layers.size();
+}
+
+void GetLayerExtensions(const char* name,
+                        const VkExtensionProperties** properties,
+                        uint32_t* count) {
+    for (const auto& layer : g_layers) {
+        if (strcmp(name, layer.properties.layerName) != 0)
+            continue;
+        *properties = layer.extensions.data();
+        *count = layer.extensions.size();
+    }
+}
+
+LayerRef GetLayerRef(const char* name) {
+    for (uint32_t id = 0; id < g_layers.size(); id++) {
+        if (strcmp(name, g_layers[id].properties.layerName) != 0) {
+            LayerLibrary& library = g_layer_libraries[g_layers[id].library_idx];
+            std::lock_guard<std::mutex> lock(g_library_mutex);
+            if (library.refcount++ == 0) {
+                library.dlhandle =
+                    dlopen(library.path.c_str(), RTLD_NOW | RTLD_LOCAL);
+                if (!library.dlhandle) {
+                    ALOGE("failed to load layer library '%s': %s",
+                          library.path.c_str(), dlerror());
+                    library.refcount = 0;
+                    return LayerRef(nullptr);
+                }
+            }
+            return LayerRef(&g_layers[id]);
+        }
+    }
+    return LayerRef(nullptr);
+}
+
+LayerRef::LayerRef(Layer* layer) : layer_(layer) {}
+
+LayerRef::~LayerRef() {
+    if (layer_) {
+        LayerLibrary& library = g_layer_libraries[layer_->library_idx];
+        std::lock_guard<std::mutex> lock(g_library_mutex);
+        if (--library.refcount == 0) {
+            dlclose(library.dlhandle);
+            library.dlhandle = nullptr;
+        }
+    }
+}
+
+LayerRef::LayerRef(LayerRef&& other) : layer_(std::move(other.layer_)) {}
+
+PFN_vkGetInstanceProcAddr LayerRef::GetGetInstanceProcAddr() const {
+    return layer_ ? reinterpret_cast<PFN_vkGetInstanceProcAddr>(
+                        GetLayerGetProcAddr(*layer_, "GetInstanceProcAddr", 19))
+                  : nullptr;
+}
+
+PFN_vkGetDeviceProcAddr LayerRef::GetGetDeviceProcAddr() const {
+    return layer_ ? reinterpret_cast<PFN_vkGetDeviceProcAddr>(
+                        GetLayerGetProcAddr(*layer_, "GetDeviceProcAddr", 17))
+                  : nullptr;
+}
+
+}  // namespace vulkan
diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
index 2d45558..551804f 100644
--- a/vulkan/libvulkan/loader.cpp
+++ b/vulkan/libvulkan/loader.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-//#define LOG_NDEBUG 0
+#define LOG_NDEBUG 0
 
 // module header
 #include "loader.h"
@@ -25,6 +25,7 @@
 #include <pthread.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/prctl.h>
 // standard C++ headers
 #include <algorithm>
 #include <mutex>
@@ -55,8 +56,7 @@
     void* base_object;
 } VkLayerLinkedListElem;
 
-// Define Handle typedef to be void* as returned from dlopen.
-typedef void* SharedLibraryHandle;
+// ----------------------------------------------------------------------------
 
 // Standard-library allocator that delegates to VkAllocationCallbacks.
 //
@@ -105,115 +105,21 @@
 template <class Key,
           class T,
           class Hash = std::hash<Key>,
-          class Pred = std::equal_to<Key> >
+          class Pred = std::equal_to<Key>>
 using UnorderedMap =
     std::unordered_map<Key,
                        T,
                        Hash,
                        Pred,
-                       CallbackAllocator<std::pair<const Key, T> > >;
+                       CallbackAllocator<std::pair<const Key, T>>>;
 
 template <class T>
-using Vector = std::vector<T, CallbackAllocator<T> >;
+using Vector = std::vector<T, CallbackAllocator<T>>;
 
-typedef std::basic_string<char,
-                          std::char_traits<char>,
-                          CallbackAllocator<char> > String;
+typedef std::basic_string<char, std::char_traits<char>, CallbackAllocator<char>>
+    String;
 
-}  // namespace
-
-// -----------------------------------------------------------------------------
-
-namespace {
-
-struct LayerData {
-    String path;
-    SharedLibraryHandle handle;
-    uint32_t ref_count;
-};
-
-typedef UnorderedMap<String, LayerData>::iterator LayerMapIterator;
-
-}  // namespace
-
-struct VkInstance_T {
-    VkInstance_T(const VkAllocationCallbacks* alloc_callbacks)
-        : vtbl(&vtbl_storage),
-          alloc(alloc_callbacks),
-          num_physical_devices(0),
-          layers(CallbackAllocator<std::pair<String, LayerData> >(alloc)),
-          active_layers(CallbackAllocator<String>(alloc)) {
-        pthread_mutex_init(&layer_lock, 0);
-        memset(&vtbl_storage, 0, sizeof(vtbl_storage));
-        memset(physical_devices, 0, sizeof(physical_devices));
-        memset(&drv.vtbl, 0, sizeof(drv.vtbl));
-        drv.GetDeviceProcAddr = nullptr;
-        drv.num_physical_devices = 0;
-    }
-
-    ~VkInstance_T() { pthread_mutex_destroy(&layer_lock); }
-
-    InstanceVtbl* vtbl;
-    InstanceVtbl vtbl_storage;
-
-    const VkAllocationCallbacks* alloc;
-    uint32_t num_physical_devices;
-    VkPhysicalDevice physical_devices[kMaxPhysicalDevices];
-
-    pthread_mutex_t layer_lock;
-    // Map of layer names to layer data
-    UnorderedMap<String, LayerData> layers;
-    // Vector of layers active for this instance
-    Vector<LayerMapIterator> active_layers;
-    VkDbgMsgCallback message;
-
-    struct Driver {
-        // Pointers to driver entry points. Used explicitly by the loader; not
-        // set as the dispatch table for any objects.
-        InstanceVtbl vtbl;
-
-        // Pointer to the driver's get_device_proc_addr, must be valid for any
-        // of the driver's physical devices. Not part of the InstanceVtbl since
-        // it's not an Instance/PhysicalDevice function.
-        PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
-
-        // Number of physical devices owned by this driver.
-        uint32_t num_physical_devices;
-    } drv;  // may eventually be an array
-};
-
-// -----------------------------------------------------------------------------
-
-namespace {
-
-typedef VkInstance_T Instance;
-
-struct Device {
-    Device(Instance* instance_input)
-        : instance(instance_input),
-          active_layers(CallbackAllocator<LayerMapIterator>(instance->alloc)) {
-        memset(&vtbl_storage, 0, sizeof(vtbl_storage));
-        vtbl_storage.device = this;
-    }
-    DeviceVtbl vtbl_storage;
-    Instance* instance;
-    // Vector of layers active for this device
-    Vector<LayerMapIterator> active_layers;
-};
-
-// -----------------------------------------------------------------------------
-// Utility Code
-
-inline const InstanceVtbl* GetVtbl(VkPhysicalDevice physicalDevice) {
-    return *reinterpret_cast<InstanceVtbl**>(physicalDevice);
-}
-
-inline const DeviceVtbl* GetVtbl(VkDevice device) {
-    return *reinterpret_cast<DeviceVtbl**>(device);
-}
-inline const DeviceVtbl* GetVtbl(VkQueue queue) {
-    return *reinterpret_cast<DeviceVtbl**>(queue);
-}
+// ----------------------------------------------------------------------------
 
 VKAPI_ATTR void* DefaultAllocate(void*,
                                  size_t size,
@@ -268,142 +174,153 @@
     .pfnFree = DefaultFree,
 };
 
-hwvulkan_device_t* g_hwdevice;
+// ----------------------------------------------------------------------------
+// Global Data and Initialization
+
+hwvulkan_device_t* g_hwdevice = nullptr;
+void LoadVulkanHAL() {
+    static const hwvulkan_module_t* module;
+    int result =
+        hw_get_module("vulkan", reinterpret_cast<const hw_module_t**>(&module));
+    if (result != 0) {
+        ALOGE("failed to load vulkan hal: %s (%d)", strerror(-result), result);
+        return;
+    }
+    result = module->common.methods->open(
+        &module->common, HWVULKAN_DEVICE_0,
+        reinterpret_cast<hw_device_t**>(&g_hwdevice));
+    if (result != 0) {
+        ALOGE("failed to open vulkan driver: %s (%d)", strerror(-result),
+              result);
+        module = nullptr;
+        return;
+    }
+}
+
 bool EnsureInitialized() {
     static std::once_flag once_flag;
-    static const hwvulkan_module_t* module;
-
     std::call_once(once_flag, []() {
-        int result;
-        result = hw_get_module("vulkan",
-                               reinterpret_cast<const hw_module_t**>(&module));
-        if (result != 0) {
-            ALOGE("failed to load vulkan hal: %s (%d)", strerror(-result),
-                  result);
-            return;
-        }
-        result = module->common.methods->open(
-            &module->common, HWVULKAN_DEVICE_0,
-            reinterpret_cast<hw_device_t**>(&g_hwdevice));
-        if (result != 0) {
-            ALOGE("failed to open vulkan driver: %s (%d)", strerror(-result),
-                  result);
-            module = nullptr;
-            return;
-        }
+        LoadVulkanHAL();
+        DiscoverLayers();
     });
-
-    return module != nullptr && g_hwdevice != nullptr;
+    return g_hwdevice != nullptr;
 }
 
+// -----------------------------------------------------------------------------
+
+struct Instance {
+    Instance(const VkAllocationCallbacks* alloc_callbacks)
+        : dispatch_ptr(&dispatch),
+          handle(reinterpret_cast<VkInstance>(&dispatch_ptr)),
+          get_instance_proc_addr(nullptr),
+          alloc(alloc_callbacks),
+          num_physical_devices(0),
+          active_layers(CallbackAllocator<LayerRef>(alloc)),
+          message(VK_NULL_HANDLE) {
+        memset(&dispatch, 0, sizeof(dispatch));
+        memset(physical_devices, 0, sizeof(physical_devices));
+        drv.instance = VK_NULL_HANDLE;
+        memset(&drv.dispatch, 0, sizeof(drv.dispatch));
+        drv.num_physical_devices = 0;
+    }
+
+    ~Instance() {}
+
+    const InstanceDispatchTable* dispatch_ptr;
+    const VkInstance handle;
+    InstanceDispatchTable dispatch;
+
+    // TODO(jessehall): Only needed by GetInstanceProcAddr_Top for
+    // vkDbg*MessageCallback. Points to the outermost layer's function. Remove
+    // once the DEBUG_CALLBACK is integrated into the API file.
+    PFN_vkGetInstanceProcAddr get_instance_proc_addr;
+
+    const VkAllocationCallbacks* alloc;
+    uint32_t num_physical_devices;
+    VkPhysicalDevice physical_devices[kMaxPhysicalDevices];
+
+    Vector<LayerRef> active_layers;
+    VkDbgMsgCallback message;
+
+    struct {
+        VkInstance instance;
+        DriverDispatchTable dispatch;
+        uint32_t num_physical_devices;
+    } drv;  // may eventually be an array
+};
+
+struct Device {
+    Device(Instance* instance_)
+        : instance(instance_),
+          active_layers(CallbackAllocator<LayerRef>(instance->alloc)) {
+        memset(&dispatch, 0, sizeof(dispatch));
+    }
+    DeviceDispatchTable dispatch;
+    Instance* instance;
+    PFN_vkGetDeviceProcAddr get_device_proc_addr;
+    Vector<LayerRef> active_layers;
+};
+
+template <typename THandle>
+struct HandleTraits {};
+template <>
+struct HandleTraits<VkInstance> {
+    typedef Instance LoaderObjectType;
+};
+template <>
+struct HandleTraits<VkPhysicalDevice> {
+    typedef Instance LoaderObjectType;
+};
+template <>
+struct HandleTraits<VkDevice> {
+    typedef Device LoaderObjectType;
+};
+template <>
+struct HandleTraits<VkQueue> {
+    typedef Device LoaderObjectType;
+};
+template <>
+struct HandleTraits<VkCommandBuffer> {
+    typedef Device LoaderObjectType;
+};
+
+template <typename THandle>
+typename HandleTraits<THandle>::LoaderObjectType& GetDispatchParent(
+    THandle handle) {
+    // TODO(jessehall): Make Instance and Device POD types (by removing the
+    // non-default constructors), so that offsetof is actually legal to use.
+    // The specific case we're using here is safe in gcc/clang (and probably
+    // most other C++ compilers), but isn't guaranteed by C++.
+    typedef typename HandleTraits<THandle>::LoaderObjectType ObjectType;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+    const size_t kDispatchOffset = offsetof(ObjectType, dispatch);
+#pragma clang diagnostic pop
+
+    const auto& dispatch = GetDispatchTable(handle);
+    uintptr_t dispatch_addr = reinterpret_cast<uintptr_t>(&dispatch);
+    uintptr_t object_addr = dispatch_addr - kDispatchOffset;
+    return *reinterpret_cast<ObjectType*>(object_addr);
+}
+
+// -----------------------------------------------------------------------------
+
 void DestroyDevice(Device* device) {
     const VkAllocationCallbacks* alloc = device->instance->alloc;
     device->~Device();
     alloc->pfnFree(alloc->pUserData, device);
 }
 
-void FindLayersInDirectory(Instance& instance, const String& dir_name) {
-    DIR* directory = opendir(dir_name.c_str());
-    if (!directory) {
-        android_LogPriority log_priority =
-            (errno == ENOENT) ? ANDROID_LOG_VERBOSE : ANDROID_LOG_ERROR;
-        LOG_PRI(log_priority, LOG_TAG,
-                "failed to open layer directory '%s': %s (%d)",
-                dir_name.c_str(), strerror(errno), errno);
-        return;
-    }
-
-    Vector<VkLayerProperties> properties(
-        CallbackAllocator<VkLayerProperties>(instance.alloc));
-    struct dirent* entry;
-    while ((entry = readdir(directory))) {
-        size_t length = strlen(entry->d_name);
-        if (strncmp(entry->d_name, "libVKLayer", 10) != 0 ||
-            strncmp(entry->d_name + length - 3, ".so", 3) != 0)
-            continue;
-        // Open so
-        SharedLibraryHandle layer_handle =
-            dlopen((dir_name + entry->d_name).c_str(), RTLD_NOW | RTLD_LOCAL);
-        if (!layer_handle) {
-            ALOGE("%s failed to load with error %s; Skipping", entry->d_name,
-                  dlerror());
-            continue;
-        }
-
-        // Get Layers in so
-        PFN_vkEnumerateInstanceLayerProperties get_layer_properties =
-            reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
-                dlsym(layer_handle, "vkEnumerateInstanceLayerProperties"));
-        if (!get_layer_properties) {
-            ALOGE(
-                "%s failed to find vkEnumerateInstanceLayerProperties with "
-                "error %s; Skipping",
-                entry->d_name, dlerror());
-            dlclose(layer_handle);
-            continue;
-        }
-        uint32_t count;
-        get_layer_properties(&count, nullptr);
-
-        properties.resize(count);
-        get_layer_properties(&count, &properties[0]);
-
-        // Add Layers to potential list
-        for (uint32_t i = 0; i < count; ++i) {
-            String layer_name(properties[i].layerName,
-                              CallbackAllocator<char>(instance.alloc));
-            LayerData layer_data = {dir_name + entry->d_name, 0, 0};
-            instance.layers.insert(std::make_pair(layer_name, layer_data));
-            ALOGV("Found layer %s", properties[i].layerName);
-        }
-        dlclose(layer_handle);
-    }
-
-    closedir(directory);
-}
-
 template <class TObject>
-void ActivateLayer(TObject* object, Instance* instance, const String& name) {
-    // If object has layer, do nothing
-    auto element = instance->layers.find(name);
-    if (element == instance->layers.end()) {
-        return;
-    }
+bool ActivateLayer(TObject* object, const char* name) {
+    LayerRef layer(GetLayerRef(name));
+    if (!layer)
+        return false;
     if (std::find(object->active_layers.begin(), object->active_layers.end(),
-                  element) != object->active_layers.end()) {
-        ALOGW("Layer %s already activated; skipping", name.c_str());
-        return;
-    }
-    // If layer is not open, open it
-    LayerData& layer_data = element->second;
-    pthread_mutex_lock(&instance->layer_lock);
-    if (layer_data.ref_count == 0) {
-        SharedLibraryHandle layer_handle =
-            dlopen(layer_data.path.c_str(), RTLD_NOW | RTLD_LOCAL);
-        if (!layer_handle) {
-            pthread_mutex_unlock(&instance->layer_lock);
-            ALOGE("%s failed to load with error %s; Skipping",
-                  layer_data.path.c_str(), dlerror());
-            return;
-        }
-        layer_data.handle = layer_handle;
-    }
-    layer_data.ref_count++;
-    pthread_mutex_unlock(&instance->layer_lock);
-    ALOGV("Activating layer %s", name.c_str());
-    object->active_layers.push_back(element);
-}
-
-void DeactivateLayer(Instance* instance,
-                     Vector<LayerMapIterator>::iterator& element) {
-    LayerMapIterator& layer_map_data = *element;
-    LayerData& layer_data = layer_map_data->second;
-    pthread_mutex_lock(&instance->layer_lock);
-    layer_data.ref_count--;
-    if (!layer_data.ref_count) {
-        dlclose(layer_data.handle);
-    }
-    pthread_mutex_unlock(&instance->layer_lock);
+                  layer) == object->active_layers.end())
+        object->active_layers.push_back(std::move(layer));
+    ALOGV("activated layer '%s'", name);
+    return true;
 }
 
 struct InstanceNamesPair {
@@ -437,13 +354,15 @@
 }
 
 template <class TInfo, class TObject>
-VkResult ActivateAllLayers(TInfo create_info, Instance* instance, TObject* object) {
+VkResult ActivateAllLayers(TInfo create_info,
+                           Instance* instance,
+                           TObject* object) {
     ALOG_ASSERT(create_info->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO ||
                     create_info->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
                 "Cannot activate layers for unknown object %p", object);
     CallbackAllocator<char> string_allocator(instance->alloc);
     // Load system layers
-    {
+    if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {
         char layer_prop[PROPERTY_VALUE_MAX];
         property_get("debug.vulkan.layers", layer_prop, "");
         String layer_name(string_allocator);
@@ -451,7 +370,7 @@
         size_t end, start = 0;
         while ((end = layer_prop_str.find(':', start)) != std::string::npos) {
             layer_name = layer_prop_str.substr(start, end - start);
-            ActivateLayer(object, instance, layer_name);
+            ActivateLayer(object, layer_name.c_str());
             start = end + 1;
         }
         Vector<String> layer_names(CallbackAllocator<String>(instance->alloc));
@@ -460,22 +379,18 @@
         property_list(SetLayerNamesFromProperty,
                       static_cast<void*>(&instance_names_pair));
         for (auto layer_name_element : layer_names) {
-            ActivateLayer(object, instance, layer_name_element);
+            ActivateLayer(object, layer_name_element.c_str());
         }
     }
     // Load app layers
-    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);
-        if (element == instance->layers.end()) {
+    for (uint32_t i = 0; i < create_info->enabledLayerCount; ++i) {
+        if (!ActivateLayer(object, create_info->ppEnabledLayerNames[i])) {
             ALOGE("requested %s layer '%s' not present",
-                create_info->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO ?
-                    "instance" : "device",
-                layer_name.c_str());
+                  create_info->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
+                      ? "instance"
+                      : "device",
+                  create_info->ppEnabledLayerNames[i]);
             return VK_ERROR_LAYER_NOT_PRESENT;
-        } else {
-            ActivateLayer(object, instance, layer_name);
         }
     }
     return VK_SUCCESS;
@@ -485,18 +400,18 @@
 bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
                               const char* extension_name,
                               const VkAllocationCallbacks* alloc) {
-    for (uint32_t i = 0; i < local_create_info.enabledExtensionNameCount; ++i) {
+    for (uint32_t i = 0; i < local_create_info.enabledExtensionCount; ++i) {
         if (!strcmp(extension_name,
                     local_create_info.ppEnabledExtensionNames[i])) {
             return false;
         }
     }
-    uint32_t extension_count = local_create_info.enabledExtensionNameCount;
-    local_create_info.enabledExtensionNameCount++;
+    uint32_t extension_count = local_create_info.enabledExtensionCount;
+    local_create_info.enabledExtensionCount++;
     void* mem = alloc->pfnAllocation(
         alloc->pUserData,
-        local_create_info.enabledExtensionNameCount * sizeof(char*),
-        alignof(char*), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+        local_create_info.enabledExtensionCount * sizeof(char*), 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 +423,7 @@
     } else {
         ALOGW("%s extension cannot be enabled: memory allocation failed",
               extension_name);
-        local_create_info.enabledExtensionNameCount--;
+        local_create_info.enabledExtensionCount--;
         return false;
     }
     return true;
@@ -539,178 +454,146 @@
     return false;
 }
 
-VkResult Noop(...) {
+VkResult Noop() {
     return VK_SUCCESS;
 }
 
-VKAPI_ATTR PFN_vkVoidFunction
-GetLayerDeviceProcAddr(VkDevice device, const char* name) {
-    if (strcmp(name, "vkGetDeviceProcAddr") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(GetLayerDeviceProcAddr);
-    }
-    if (strcmp(name, "vkCreateDevice") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(Noop);
-    }
-    // WSI extensions are not in the driver so return the loader functions
-    if (strcmp(name, "vkCreateSwapchainKHR") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR);
-    }
-    if (strcmp(name, "vkDestroySwapchainKHR") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR);
-    }
-    if (strcmp(name, "vkGetSwapchainImagesKHR") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR);
-    }
-    if (strcmp(name, "vkAcquireNextImageKHR") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR);
-    }
-    if (strcmp(name, "vkQueuePresentKHR") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR);
-    }
-    if (!device)
-        return GetGlobalDeviceProcAddr(name);
-    Device* loader_device = reinterpret_cast<Device*>(GetVtbl(device)->device);
-    return loader_device->instance->drv.GetDeviceProcAddr(device, name);
-}
+}  // anonymous namespace
+
+namespace vulkan {
 
 // -----------------------------------------------------------------------------
 // "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
-    // 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,
-                                           allocator);
-    }
-    if (instance->message) {
-        PFN_vkDbgDestroyMsgCallback DebugDestroyMessageCallback;
-        DebugDestroyMessageCallback =
-            reinterpret_cast<PFN_vkDbgDestroyMsgCallback>(
-                vkGetInstanceProcAddr(instance, "vkDbgDestroyMsgCallback"));
-        DebugDestroyMessageCallback(instance, instance->message);
-    }
-    for (auto it = instance->active_layers.begin();
-         it != instance->active_layers.end(); ++it) {
-        DeactivateLayer(instance, it);
-    }
-    const VkAllocationCallbacks* alloc = instance->alloc;
-    instance->~VkInstance_T();
-    alloc->pfnFree(alloc->pUserData, instance);
-}
-
-VKAPI_ATTR
-VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
-                              const VkAllocationCallbacks* allocator,
-                              VkInstance* instance_ptr) {
-    Instance* instance = *instance_ptr;
+VkResult CreateInstance_Bottom(const VkInstanceCreateInfo* create_info,
+                               const VkAllocationCallbacks* allocator,
+                               VkInstance* vkinstance) {
+    Instance& instance = GetDispatchParent(*vkinstance);
     VkResult result;
 
-    result = g_hwdevice->CreateInstance(create_info, instance->alloc,
-                                        &instance->drv.vtbl.instance);
+    result = g_hwdevice->CreateInstance(create_info, instance.alloc,
+                                        &instance.drv.instance);
     if (result != VK_SUCCESS) {
-        DestroyInstanceBottom(instance, allocator);
+        DestroyInstance_Bottom(instance.handle, allocator);
         return result;
     }
 
-    if (!LoadInstanceVtbl(
-            instance->drv.vtbl.instance, instance->drv.vtbl.instance,
-            g_hwdevice->GetInstanceProcAddr, instance->drv.vtbl)) {
-        DestroyInstanceBottom(instance, allocator);
+    if (!LoadDriverDispatchTable(instance.drv.instance,
+                                 g_hwdevice->GetInstanceProcAddr,
+                                 instance.drv.dispatch)) {
+        DestroyInstance_Bottom(instance.handle, allocator);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
-    // vkGetDeviceProcAddr has a bootstrapping problem. We require that it be
-    // queryable from the Instance, and that the resulting function work for any
-    // VkDevice created from the instance.
-    instance->drv.GetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(
-        g_hwdevice->GetInstanceProcAddr(instance->drv.vtbl.instance,
-                                        "vkGetDeviceProcAddr"));
-    if (!instance->drv.GetDeviceProcAddr) {
-        ALOGE("missing instance proc: \"%s\"", "vkGetDeviceProcAddr");
-        DestroyInstanceBottom(instance, allocator);
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-    hwvulkan_dispatch_t* dispatch =
-        reinterpret_cast<hwvulkan_dispatch_t*>(instance->drv.vtbl.instance);
-    if (dispatch->magic == HWVULKAN_DISPATCH_MAGIC) {
-        // Skip setting dispatch->vtbl on the driver instance handle, since we
-        // never intentionally call through it; we go through Instance::drv.vtbl
-        // instead.
+    hwvulkan_dispatch_t* drv_dispatch =
+        reinterpret_cast<hwvulkan_dispatch_t*>(instance.drv.instance);
+    if (drv_dispatch->magic == HWVULKAN_DISPATCH_MAGIC) {
+        // Skip setting drv_dispatch->vtbl, since we never call through it;
+        // we go through instance.drv.dispatch instead.
     } else {
         ALOGE("invalid VkInstance dispatch magic: 0x%" PRIxPTR,
-              dispatch->magic);
-        DestroyInstanceBottom(instance, allocator);
+              drv_dispatch->magic);
+        DestroyInstance_Bottom(instance.handle, allocator);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
     uint32_t num_physical_devices = 0;
-    result = instance->drv.vtbl.EnumeratePhysicalDevices(
-        instance->drv.vtbl.instance, &num_physical_devices, nullptr);
+    result = instance.drv.dispatch.EnumeratePhysicalDevices(
+        instance.drv.instance, &num_physical_devices, nullptr);
     if (result != VK_SUCCESS) {
-        DestroyInstanceBottom(instance, allocator);
+        DestroyInstance_Bottom(instance.handle, allocator);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
     num_physical_devices = std::min(num_physical_devices, kMaxPhysicalDevices);
-    result = instance->drv.vtbl.EnumeratePhysicalDevices(
-        instance->drv.vtbl.instance, &num_physical_devices,
-        instance->physical_devices);
+    result = instance.drv.dispatch.EnumeratePhysicalDevices(
+        instance.drv.instance, &num_physical_devices,
+        instance.physical_devices);
     if (result != VK_SUCCESS) {
-        DestroyInstanceBottom(instance, allocator);
+        DestroyInstance_Bottom(instance.handle, allocator);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
     for (uint32_t i = 0; i < num_physical_devices; i++) {
-        dispatch = reinterpret_cast<hwvulkan_dispatch_t*>(
-            instance->physical_devices[i]);
-        if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
+        hwvulkan_dispatch_t* pdev_dispatch =
+            reinterpret_cast<hwvulkan_dispatch_t*>(
+                instance.physical_devices[i]);
+        if (pdev_dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
             ALOGE("invalid VkPhysicalDevice dispatch magic: 0x%" PRIxPTR,
-                  dispatch->magic);
-            DestroyInstanceBottom(instance, allocator);
+                  pdev_dispatch->magic);
+            DestroyInstance_Bottom(instance.handle, allocator);
             return VK_ERROR_INITIALIZATION_FAILED;
         }
-        dispatch->vtbl = instance->vtbl;
+        pdev_dispatch->vtbl = instance.dispatch_ptr;
     }
-    instance->drv.num_physical_devices = num_physical_devices;
+    instance.drv.num_physical_devices = num_physical_devices;
 
-    instance->num_physical_devices = instance->drv.num_physical_devices;
+    instance.num_physical_devices = instance.drv.num_physical_devices;
     return VK_SUCCESS;
 }
 
-VKAPI_ATTR
-VkResult EnumeratePhysicalDevicesBottom(VkInstance instance,
-                                        uint32_t* pdev_count,
-                                        VkPhysicalDevice* pdevs) {
-    uint32_t count = instance->num_physical_devices;
+PFN_vkVoidFunction GetInstanceProcAddr_Bottom(VkInstance, const char* name) {
+    PFN_vkVoidFunction pfn;
+    if ((pfn = GetLoaderBottomProcAddr(name)))
+        return pfn;
+    // TODO: Possibly move this into the instance table
+    // TODO: Possibly register the callbacks in the loader
+    if (strcmp(name, "vkDbgCreateMsgCallback") == 0 ||
+        strcmp(name, "vkDbgDestroyMsgCallback") == 0) {
+        return reinterpret_cast<PFN_vkVoidFunction>(Noop);
+    }
+    return nullptr;
+}
+
+VkResult EnumeratePhysicalDevices_Bottom(VkInstance vkinstance,
+                                         uint32_t* pdev_count,
+                                         VkPhysicalDevice* pdevs) {
+    Instance& instance = GetDispatchParent(vkinstance);
+    uint32_t count = instance.num_physical_devices;
     if (pdevs) {
         count = std::min(count, *pdev_count);
-        std::copy(instance->physical_devices,
-                  instance->physical_devices + count, pdevs);
+        std::copy(instance.physical_devices, instance.physical_devices + count,
+                  pdevs);
     }
     *pdev_count = count;
     return VK_SUCCESS;
 }
 
-VKAPI_ATTR
-void GetPhysicalDeviceFeaturesBottom(VkPhysicalDevice pdev,
-                                     VkPhysicalDeviceFeatures* features) {
-    GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFeatures(pdev, features);
+void GetPhysicalDeviceProperties_Bottom(
+    VkPhysicalDevice pdev,
+    VkPhysicalDeviceProperties* properties) {
+    GetDispatchParent(pdev).drv.dispatch.GetPhysicalDeviceProperties(
+        pdev, properties);
 }
 
-VKAPI_ATTR
-void GetPhysicalDeviceFormatPropertiesBottom(VkPhysicalDevice pdev,
-                                             VkFormat format,
-                                             VkFormatProperties* properties) {
-    GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFormatProperties(
+void GetPhysicalDeviceFeatures_Bottom(VkPhysicalDevice pdev,
+                                      VkPhysicalDeviceFeatures* features) {
+    GetDispatchParent(pdev).drv.dispatch.GetPhysicalDeviceFeatures(pdev,
+                                                                   features);
+}
+
+void GetPhysicalDeviceMemoryProperties_Bottom(
+    VkPhysicalDevice pdev,
+    VkPhysicalDeviceMemoryProperties* properties) {
+    GetDispatchParent(pdev).drv.dispatch.GetPhysicalDeviceMemoryProperties(
+        pdev, properties);
+}
+
+void GetPhysicalDeviceQueueFamilyProperties_Bottom(
+    VkPhysicalDevice pdev,
+    uint32_t* pCount,
+    VkQueueFamilyProperties* properties) {
+    GetDispatchParent(pdev).drv.dispatch.GetPhysicalDeviceQueueFamilyProperties(
+        pdev, pCount, properties);
+}
+
+void GetPhysicalDeviceFormatProperties_Bottom(VkPhysicalDevice pdev,
+                                              VkFormat format,
+                                              VkFormatProperties* properties) {
+    GetDispatchParent(pdev).drv.dispatch.GetPhysicalDeviceFormatProperties(
         pdev, format, properties);
 }
 
-VKAPI_ATTR
-VkResult GetPhysicalDeviceImageFormatPropertiesBottom(
+VkResult GetPhysicalDeviceImageFormatProperties_Bottom(
     VkPhysicalDevice pdev,
     VkFormat format,
     VkImageType type,
@@ -718,41 +601,52 @@
     VkImageUsageFlags usage,
     VkImageCreateFlags flags,
     VkImageFormatProperties* properties) {
-    return GetVtbl(pdev)
-        ->instance->drv.vtbl.GetPhysicalDeviceImageFormatProperties(
+    return GetDispatchParent(pdev)
+        .drv.dispatch.GetPhysicalDeviceImageFormatProperties(
             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(
+void GetPhysicalDeviceSparseImageFormatProperties_Bottom(
     VkPhysicalDevice pdev,
-    uint32_t* pCount,
-    VkQueueFamilyProperties* properties) {
-    GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceQueueFamilyProperties(
-        pdev, pCount, properties);
+    VkFormat format,
+    VkImageType type,
+    VkSampleCountFlagBits samples,
+    VkImageUsageFlags usage,
+    VkImageTiling tiling,
+    uint32_t* properties_count,
+    VkSparseImageFormatProperties* properties) {
+    GetDispatchParent(pdev)
+        .drv.dispatch.GetPhysicalDeviceSparseImageFormatProperties(
+            pdev, format, type, samples, usage, tiling, properties_count,
+            properties);
 }
 
 VKAPI_ATTR
-void GetPhysicalDeviceMemoryPropertiesBottom(
-    VkPhysicalDevice pdev,
-    VkPhysicalDeviceMemoryProperties* properties) {
-    GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceMemoryProperties(
-        pdev, properties);
+VkResult EnumerateDeviceExtensionProperties_Bottom(
+    VkPhysicalDevice /*pdev*/,
+    const char* /*layer_name*/,
+    uint32_t* properties_count,
+    VkExtensionProperties* /*properties*/) {
+    // TODO(jessehall): Implement me...
+    *properties_count = 0;
+    return VK_SUCCESS;
 }
 
 VKAPI_ATTR
-VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
-                            const VkDeviceCreateInfo* create_info,
-                            const VkAllocationCallbacks* allocator,
-                            VkDevice* out_device) {
-    Instance& instance = *static_cast<Instance*>(GetVtbl(pdev)->instance);
+VkResult EnumerateDeviceLayerProperties_Bottom(VkPhysicalDevice /*pdev*/,
+                                               uint32_t* properties_count,
+                                               VkLayerProperties* /*properties*/) {
+    // TODO(jessehall): Implement me...
+    *properties_count = 0;
+    return VK_SUCCESS;
+}
+
+VKAPI_ATTR
+VkResult CreateDevice_Bottom(VkPhysicalDevice pdev,
+                             const VkDeviceCreateInfo* create_info,
+                             const VkAllocationCallbacks* allocator,
+                             VkDevice* device_out) {
+    Instance& instance = GetDispatchParent(pdev);
     VkResult result;
 
     if (!allocator) {
@@ -776,30 +670,35 @@
     }
 
     VkDevice drv_device;
-    result = instance.drv.vtbl.CreateDevice(pdev, create_info, allocator,
-                                            &drv_device);
+    result = instance.drv.dispatch.CreateDevice(pdev, create_info, allocator,
+                                                &drv_device);
     if (result != VK_SUCCESS) {
         DestroyDevice(device);
         return result;
     }
 
-    hwvulkan_dispatch_t* dispatch =
+    hwvulkan_dispatch_t* drv_dispatch =
         reinterpret_cast<hwvulkan_dispatch_t*>(drv_device);
-    if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
-        ALOGE("invalid VkDevice dispatch magic: 0x%" PRIxPTR, dispatch->magic);
+    if (drv_dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
+        ALOGE("invalid VkDevice dispatch magic: 0x%" PRIxPTR,
+              drv_dispatch->magic);
         PFN_vkDestroyDevice destroy_device =
             reinterpret_cast<PFN_vkDestroyDevice>(
-                instance.drv.GetDeviceProcAddr(drv_device, "vkDestroyDevice"));
+                instance.drv.dispatch.GetDeviceProcAddr(drv_device,
+                                                        "vkDestroyDevice"));
         destroy_device(drv_device, allocator);
         DestroyDevice(device);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
-    dispatch->vtbl = &device->vtbl_storage;
+    drv_dispatch->vtbl = &device->dispatch;
+    device->get_device_proc_addr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(
+        instance.drv.dispatch.GetDeviceProcAddr(drv_device,
+                                                "vkGetDeviceProcAddr"));
 
     void* base_object = static_cast<void*>(drv_device);
     void* next_object = base_object;
     VkLayerLinkedListElem* next_element;
-    PFN_vkGetDeviceProcAddr next_get_proc_addr = GetLayerDeviceProcAddr;
+    PFN_vkGetDeviceProcAddr next_get_proc_addr = GetDeviceProcAddr_Bottom;
     Vector<VkLayerLinkedListElem> elem_list(
         device->active_layers.size(),
         CallbackAllocator<VkLayerLinkedListElem>(instance.alloc));
@@ -813,162 +712,138 @@
         next_element->next_element = next_object;
         next_object = static_cast<void*>(next_element);
 
-        auto& name = device->active_layers[idx]->first;
-        auto& handle = device->active_layers[idx]->second.handle;
-        next_get_proc_addr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(
-            dlsym(handle, (name + "GetDeviceProcAddr").c_str()));
+        next_get_proc_addr = device->active_layers[idx].GetGetDeviceProcAddr();
         if (!next_get_proc_addr) {
+            next_object = next_element->next_element;
             next_get_proc_addr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(
-                dlsym(handle, "vkGetDeviceProcAddr"));
-            if (!next_get_proc_addr) {
-                ALOGE("Cannot find vkGetDeviceProcAddr for %s, error is %s",
-                      name.c_str(), dlerror());
-                next_object = next_element->next_element;
-                next_get_proc_addr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(
-                    next_element->get_proc_addr);
-            }
+                next_element->get_proc_addr);
         }
     }
 
-    if (!LoadDeviceVtbl(static_cast<VkDevice>(base_object),
-                        static_cast<VkDevice>(next_object), next_get_proc_addr,
-                        device->vtbl_storage)) {
+    // This is the magic call that initializes all the layer devices and
+    // allows them to create their device_handle -> device_data mapping.
+    next_get_proc_addr(static_cast<VkDevice>(next_object),
+                       "vkGetDeviceProcAddr");
+
+    // We must create all the layer devices *before* retrieving the device
+    // procaddrs, so that the layers know which extensions are enabled and
+    // therefore which functions to return procaddrs for.
+    PFN_vkCreateDevice create_device = reinterpret_cast<PFN_vkCreateDevice>(
+        next_get_proc_addr(drv_device, "vkCreateDevice"));
+    create_device(pdev, create_info, allocator, &drv_device);
+
+    if (!LoadDeviceDispatchTable(static_cast<VkDevice>(base_object),
+                                 next_get_proc_addr, device->dispatch)) {
         DestroyDevice(device);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
-    PFN_vkCreateDevice layer_createDevice =
-        reinterpret_cast<PFN_vkCreateDevice>(
-            device->vtbl_storage.GetDeviceProcAddr(drv_device,
-                                                   "vkCreateDevice"));
-    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.
-    if (!LoadDeviceVtbl(static_cast<VkDevice>(base_object),
-                        static_cast<VkDevice>(next_object), next_get_proc_addr,
-                        device->vtbl_storage)) {
-        DestroyDevice(device);
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-    *out_device = drv_device;
+    *device_out = drv_device;
     return VK_SUCCESS;
 }
 
-VKAPI_ATTR
-VkResult EnumerateDeviceExtensionPropertiesBottom(
-    VkPhysicalDevice pdev,
+void DestroyInstance_Bottom(VkInstance vkinstance,
+                            const VkAllocationCallbacks* allocator) {
+    Instance& instance = GetDispatchParent(vkinstance);
+
+    // These checks allow us to call DestroyInstance_Bottom from any error
+    // path in CreateInstance_Bottom, before the driver instance is fully
+    // initialized.
+    if (instance.drv.instance != VK_NULL_HANDLE &&
+        instance.drv.dispatch.DestroyInstance) {
+        instance.drv.dispatch.DestroyInstance(instance.drv.instance, allocator);
+    }
+    if (instance.message) {
+        PFN_vkDbgDestroyMsgCallback DebugDestroyMessageCallback;
+        DebugDestroyMessageCallback =
+            reinterpret_cast<PFN_vkDbgDestroyMsgCallback>(
+                vkGetInstanceProcAddr(vkinstance, "vkDbgDestroyMsgCallback"));
+        DebugDestroyMessageCallback(vkinstance, instance.message);
+    }
+    instance.active_layers.clear();
+    const VkAllocationCallbacks* alloc = instance.alloc;
+    instance.~Instance();
+    alloc->pfnFree(alloc->pUserData, &instance);
+}
+
+PFN_vkVoidFunction GetDeviceProcAddr_Bottom(VkDevice vkdevice,
+                                            const char* name) {
+    if (strcmp(name, "vkCreateDevice") == 0) {
+        // TODO(jessehall): Blegh, having this here is disgusting. The current
+        // layer init process can't call through the instance dispatch table's
+        // vkCreateDevice, because that goes through the instance layers rather
+        // than through the device layers. So we need to be able to get the
+        // vkCreateDevice pointer through the *device* layer chain.
+        //
+        // Because we've already created the driver device before calling
+        // through the layer vkCreateDevice functions, the loader bottom proc
+        // is a no-op.
+        return reinterpret_cast<PFN_vkVoidFunction>(Noop);
+    }
+
+    // VK_ANDROID_native_buffer should be hidden from applications and layers.
+    // TODO(jessehall): Generate this as part of GetLoaderBottomProcAddr.
+    PFN_vkVoidFunction pfn;
+    if (strcmp(name, "vkGetSwapchainGrallocUsageANDROID") == 0 ||
+        strcmp(name, "vkAcquireImageANDROID") == 0 ||
+        strcmp(name, "vkQueueSignalReleaseImageANDROID") == 0) {
+        return nullptr;
+    }
+    if ((pfn = GetLoaderBottomProcAddr(name)))
+        return pfn;
+    return GetDispatchParent(vkdevice).get_device_proc_addr(vkdevice, name);
+}
+
+// -----------------------------------------------------------------------------
+// Loader top functions. These are called directly from the loader entry
+// points or from the application (via vkGetInstanceProcAddr) without going
+// through a dispatch table.
+
+VkResult EnumerateInstanceExtensionProperties_Top(
     const char* layer_name,
     uint32_t* properties_count,
     VkExtensionProperties* properties) {
-    // TODO: what are we supposed to do with layer_name here?
-    return GetVtbl(pdev)->instance->drv.vtbl.EnumerateDeviceExtensionProperties(
-        pdev, layer_name, properties_count, properties);
+    if (!EnsureInitialized())
+        return VK_ERROR_INITIALIZATION_FAILED;
+
+    const VkExtensionProperties* extensions = nullptr;
+    uint32_t num_extensions = 0;
+    if (layer_name) {
+        GetLayerExtensions(layer_name, &extensions, &num_extensions);
+    } else {
+        static const VkExtensionProperties kInstanceExtensions[] = {
+            {VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION},
+            {VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
+             VK_KHR_ANDROID_SURFACE_SPEC_VERSION}};
+        extensions = kInstanceExtensions;
+        num_extensions = sizeof(kInstanceExtensions) / sizeof(kInstanceExtensions[0]);
+        // TODO(jessehall): We need to also enumerate extensions supported by
+        // implicitly-enabled layers. Currently we don't have that list of
+        // layers until instance creation.
+    }
+
+    if (!properties || *properties_count > num_extensions)
+        *properties_count = num_extensions;
+    if (properties)
+        std::copy(extensions, extensions + *properties_count, properties);
+    return *properties_count < num_extensions ? VK_INCOMPLETE : VK_SUCCESS;
 }
 
-VKAPI_ATTR
-VkResult EnumerateDeviceLayerPropertiesBottom(VkPhysicalDevice pdev,
-                                              uint32_t* properties_count,
+VkResult EnumerateInstanceLayerProperties_Top(uint32_t* properties_count,
                                               VkLayerProperties* properties) {
-    return GetVtbl(pdev)->instance->drv.vtbl.EnumerateDeviceLayerProperties(
-        pdev, properties_count, properties);
-}
-
-VKAPI_ATTR
-void GetPhysicalDeviceSparseImageFormatPropertiesBottom(
-    VkPhysicalDevice pdev,
-    VkFormat format,
-    VkImageType type,
-    VkSampleCountFlagBits samples,
-    VkImageUsageFlags usage,
-    VkImageTiling tiling,
-    uint32_t* properties_count,
-    VkSparseImageFormatProperties* properties) {
-    GetVtbl(pdev)
-        ->instance->drv.vtbl.GetPhysicalDeviceSparseImageFormatProperties(
-            pdev, format, type, samples, usage, tiling, properties_count,
-            properties);
-}
-
-VKAPI_ATTR PFN_vkVoidFunction
-GetInstanceProcAddrBottom(VkInstance, const char*);
-
-const InstanceVtbl kBottomInstanceFunctions = {
-    // clang-format off
-    .instance = nullptr,
-    .CreateInstance = CreateInstanceBottom,
-    .DestroyInstance = DestroyInstanceBottom,
-    .GetInstanceProcAddr = GetInstanceProcAddrBottom,
-    .EnumeratePhysicalDevices = EnumeratePhysicalDevicesBottom,
-    .GetPhysicalDeviceFeatures = GetPhysicalDeviceFeaturesBottom,
-    .GetPhysicalDeviceFormatProperties = GetPhysicalDeviceFormatPropertiesBottom,
-    .GetPhysicalDeviceImageFormatProperties = GetPhysicalDeviceImageFormatPropertiesBottom,
-    .GetPhysicalDeviceProperties = GetPhysicalDevicePropertiesBottom,
-    .GetPhysicalDeviceQueueFamilyProperties = GetPhysicalDeviceQueueFamilyPropertiesBottom,
-    .GetPhysicalDeviceMemoryProperties = GetPhysicalDeviceMemoryPropertiesBottom,
-    .CreateDevice = CreateDeviceBottom,
-    .EnumerateDeviceExtensionProperties = EnumerateDeviceExtensionPropertiesBottom,
-    .EnumerateDeviceLayerProperties = EnumerateDeviceLayerPropertiesBottom,
-    .GetPhysicalDeviceSparseImageFormatProperties = GetPhysicalDeviceSparseImageFormatPropertiesBottom,
-    .GetPhysicalDeviceSurfaceSupportKHR = GetPhysicalDeviceSurfaceSupportKHR,
-    .GetPhysicalDeviceSurfaceCapabilitiesKHR = GetPhysicalDeviceSurfaceCapabilitiesKHR,
-    .GetPhysicalDeviceSurfaceFormatsKHR = GetPhysicalDeviceSurfaceFormatsKHR,
-    .GetPhysicalDeviceSurfacePresentModesKHR = GetPhysicalDeviceSurfacePresentModesKHR,
-    // 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
-    if (strcmp(name, "vkDbgCreateMsgCallback") == 0 ||
-        strcmp(name, "vkDbgDestroyMsgCallback") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(Noop);
-    }
-    if (strcmp(name, "vkCreateInstance") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(CreateInstanceBottom);
-    }
-    return GetSpecificInstanceProcAddr(&kBottomInstanceFunctions, name);
-}
-
-}  // namespace
-
-// -----------------------------------------------------------------------------
-// Global functions. These are called directly from the loader entry points,
-// without going through a dispatch table.
-
-namespace vulkan {
-
-VkResult EnumerateInstanceExtensionProperties(
-    const char* /*layer_name*/,
-    uint32_t* count,
-    VkExtensionProperties* /*properties*/) {
     if (!EnsureInitialized())
         return VK_ERROR_INITIALIZATION_FAILED;
 
-    // TODO: not yet implemented
-    ALOGW("vkEnumerateInstanceExtensionProperties not implemented");
-
-    *count = 0;
-    return VK_SUCCESS;
+    uint32_t layer_count =
+        EnumerateLayers(properties ? *properties_count : 0, properties);
+    if (!properties || *properties_count > layer_count)
+        *properties_count = layer_count;
+    return *properties_count < layer_count ? VK_INCOMPLETE : VK_SUCCESS;
 }
 
-VkResult EnumerateInstanceLayerProperties(uint32_t* count,
-                                          VkLayerProperties* /*properties*/) {
-    if (!EnsureInitialized())
-        return VK_ERROR_INITIALIZATION_FAILED;
-
-    // TODO: not yet implemented
-    ALOGW("vkEnumerateInstanceLayerProperties not implemented");
-
-    *count = 0;
-    return VK_SUCCESS;
-}
-
-VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
-                        const VkAllocationCallbacks* allocator,
-                        VkInstance* out_instance) {
+VkResult CreateInstance_Top(const VkInstanceCreateInfo* create_info,
+                            const VkAllocationCallbacks* allocator,
+                            VkInstance* instance_out) {
     VkResult result;
 
     if (!EnsureInitialized())
@@ -987,31 +862,16 @@
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     Instance* instance = new (instance_mem) Instance(allocator);
 
-    instance->vtbl_storage = kBottomInstanceFunctions;
-    instance->vtbl_storage.instance = instance;
-    instance->message = VK_NULL_HANDLE;
-
-    // Scan layers
-    CallbackAllocator<char> string_allocator(instance->alloc);
-
-    String dir_name("/data/local/tmp/vulkan/", string_allocator);
-    FindLayersInDirectory(*instance, dir_name);
-    const std::string& path = LoaderData::GetInstance().layer_path;
-    dir_name.assign(path.c_str(), path.size());
-    dir_name.append("/");
-    FindLayersInDirectory(*instance, dir_name);
-
     result = ActivateAllLayers(create_info, instance, instance);
     if (result != VK_SUCCESS) {
-        DestroyInstanceBottom(instance, allocator);
+        DestroyInstance_Bottom(instance->handle, allocator);
         return result;
     }
 
-    void* base_object = static_cast<void*>(instance);
+    void* base_object = static_cast<void*>(instance->handle);
     void* next_object = base_object;
     VkLayerLinkedListElem* next_element;
-    PFN_vkGetInstanceProcAddr next_get_proc_addr =
-        kBottomInstanceFunctions.GetInstanceProcAddr;
+    PFN_vkGetInstanceProcAddr next_get_proc_addr = GetInstanceProcAddr_Bottom;
     Vector<VkLayerLinkedListElem> elem_list(
         instance->active_layers.size(),
         CallbackAllocator<VkLayerLinkedListElem>(instance->alloc));
@@ -1025,44 +885,45 @@
         next_element->next_element = next_object;
         next_object = static_cast<void*>(next_element);
 
-        auto& name = instance->active_layers[idx]->first;
-        auto& handle = instance->active_layers[idx]->second.handle;
-        next_get_proc_addr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(
-            dlsym(handle, (name + "GetInstanceProcAddr").c_str()));
+        next_get_proc_addr =
+            instance->active_layers[idx].GetGetInstanceProcAddr();
         if (!next_get_proc_addr) {
+            next_object = next_element->next_element;
             next_get_proc_addr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(
-                dlsym(handle, "vkGetInstanceProcAddr"));
-            if (!next_get_proc_addr) {
-                ALOGE("Cannot find vkGetInstanceProcAddr for %s, error is %s",
-                      name.c_str(), dlerror());
-                next_object = next_element->next_element;
-                next_get_proc_addr =
-                    reinterpret_cast<PFN_vkGetInstanceProcAddr>(
-                        next_element->get_proc_addr);
-            }
+                next_element->get_proc_addr);
         }
     }
+    instance->get_instance_proc_addr = next_get_proc_addr;
 
-    if (!LoadInstanceVtbl(static_cast<VkInstance>(base_object),
-                          static_cast<VkInstance>(next_object),
-                          next_get_proc_addr, instance->vtbl_storage)) {
-        DestroyInstanceBottom(instance, allocator);
+    // This is the magic call that initializes all the layer instances and
+    // allows them to create their instance_handle -> instance_data mapping.
+    next_get_proc_addr(static_cast<VkInstance>(next_object),
+                       "vkGetInstanceProcAddr");
+
+    if (!LoadInstanceDispatchTable(static_cast<VkInstance>(base_object),
+                                   next_get_proc_addr, instance->dispatch)) {
+        DestroyInstance_Bottom(instance->handle, allocator);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
     // Force enable callback extension if required
-    bool enable_callback =
-        property_get_bool("debug.vulkan.enable_callback", false);
-    bool enable_logging = enable_callback;
-    const char* extension_name = "DEBUG_REPORT";
-    if (enable_callback) {
-        enable_callback = AddExtensionToCreateInfo(
-            local_create_info, extension_name, instance->alloc);
+    bool enable_callback = false;
+    bool enable_logging = false;
+    if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {
+        enable_callback =
+            property_get_bool("debug.vulkan.enable_callback", false);
+        enable_logging = enable_callback;
+        if (enable_callback) {
+            enable_callback = AddExtensionToCreateInfo(
+                local_create_info, "DEBUG_REPORT", instance->alloc);
+        }
     }
 
-    *out_instance = instance;
-    result = instance->vtbl_storage.CreateInstance(create_info, allocator,
-                                                   out_instance);
+    *instance_out = instance->handle;
+    PFN_vkCreateInstance create_instance =
+        reinterpret_cast<PFN_vkCreateInstance>(
+            next_get_proc_addr(instance->handle, "vkCreateInstance"));
+    result = create_instance(create_info, allocator, instance_out);
     if (enable_callback)
         FreeAllocatedCreateInfo(local_create_info, instance->alloc);
     if (result <= 0) {
@@ -1076,151 +937,127 @@
         // - The layer must not call the next layer's DestroyInstance if that
         //   layer's CreateInstance wasn't called, or returned failure.
 
-        // On failure, CreateInstanceBottom frees the instance struct, so it's
+        // On failure, CreateInstance_Bottom frees the instance struct, so it's
         // already gone at this point. Nothing to do.
     }
 
     if (enable_logging) {
-        PFN_vkDbgCreateMsgCallback DebugCreateMessageCallback;
-        DebugCreateMessageCallback =
-            reinterpret_cast<PFN_vkDbgCreateMsgCallback>(
-                vkGetInstanceProcAddr(instance, "vkDbgCreateMsgCallback"));
-        DebugCreateMessageCallback(
-            instance, VK_DBG_REPORT_ERROR_BIT | VK_DBG_REPORT_WARN_BIT,
-            LogDebugMessageCallback, NULL, &instance->message);
+        PFN_vkDbgCreateMsgCallback dbg_create_msg_callback;
+        dbg_create_msg_callback = reinterpret_cast<PFN_vkDbgCreateMsgCallback>(
+            GetInstanceProcAddr_Top(instance->handle,
+                                    "vkDbgCreateMsgCallback"));
+        dbg_create_msg_callback(
+            instance->handle, VK_DBG_REPORT_ERROR_BIT | VK_DBG_REPORT_WARN_BIT,
+            LogDebugMessageCallback, nullptr, &instance->message);
     }
 
     return result;
 }
 
-PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
-    if (!instance)
-        return GetGlobalInstanceProcAddr(name);
-    // TODO: Possibly move this into the instance table
+PFN_vkVoidFunction GetInstanceProcAddr_Top(VkInstance vkinstance,
+                                           const char* name) {
+    // vkGetInstanceProcAddr(NULL_HANDLE, ..) only works for global commands
+    if (!vkinstance)
+        return GetLoaderGlobalProcAddr(name);
+
+    const InstanceDispatchTable& dispatch = GetDispatchTable(vkinstance);
+    PFN_vkVoidFunction pfn;
+    // Always go through the loader-top function if there is one.
+    if ((pfn = GetLoaderTopProcAddr(name)))
+        return pfn;
+    // Otherwise, look up the handler in the instance dispatch table
+    if ((pfn = GetDispatchProcAddr(dispatch, name)))
+        return pfn;
+    // TODO(jessehall): Generate these into the instance dispatch table, and
+    // add loader-bottom procs for them.
     if (strcmp(name, "vkDbgCreateMsgCallback") == 0 ||
         strcmp(name, "vkDbgDestroyMsgCallback") == 0) {
-        if (!instance->vtbl)
-            return NULL;
-        PFN_vkGetInstanceProcAddr gpa = instance->vtbl->GetInstanceProcAddr;
-        return reinterpret_cast<PFN_vkVoidFunction>(gpa(instance, name));
+        return GetDispatchParent(vkinstance)
+            .get_instance_proc_addr(vkinstance, name);
     }
-    // For special-case functions we always return the loader entry
-    if (strcmp(name, "vkGetInstanceProcAddr") == 0 ||
-        strcmp(name, "vkGetDeviceProcAddr") == 0) {
-        return GetGlobalInstanceProcAddr(name);
-    }
-    return GetSpecificInstanceProcAddr(instance->vtbl, name);
+    // Anything not handled already must be a device-dispatched function
+    // without a loader-top. We must return a function that will dispatch based
+    // on the dispatchable object parameter -- which is exactly what the
+    // exported functions do. So just return them here.
+    return GetLoaderExportProcAddr(name);
 }
 
-PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* name) {
+void DestroyInstance_Top(VkInstance instance,
+                         const VkAllocationCallbacks* allocator) {
+    if (!instance)
+        return;
+    GetDispatchTable(instance).DestroyInstance(instance, allocator);
+}
+
+PFN_vkVoidFunction GetDeviceProcAddr_Top(VkDevice device, const char* name) {
+    PFN_vkVoidFunction pfn;
     if (!device)
-        return GetGlobalDeviceProcAddr(name);
-    if (strcmp(name, "vkGetDeviceProcAddr") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr);
-    }
-    if (strcmp(name, "vkGetDeviceQueue") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(GetDeviceQueue);
-    }
-    if (strcmp(name, "vkAllocCommandBuffers") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(AllocCommandBuffers);
-    }
-    if (strcmp(name, "vkDestroyDevice") == 0) {
-        return reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice);
-    }
-    return GetSpecificDeviceProcAddr(GetVtbl(device), name);
+        return nullptr;
+    if ((pfn = GetLoaderTopProcAddr(name)))
+        return pfn;
+    return GetDispatchProcAddr(GetDispatchTable(device), name);
 }
 
-void GetDeviceQueue(VkDevice drv_device,
-                    uint32_t family,
-                    uint32_t index,
-                    VkQueue* out_queue) {
-    VkResult result;
-    VkQueue queue;
-    const DeviceVtbl* vtbl = GetVtbl(drv_device);
-    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)
-        ALOGE("invalid VkQueue dispatch magic: 0x%" PRIxPTR, dispatch->magic);
-    dispatch->vtbl = vtbl;
-    *out_queue = queue;
+void GetDeviceQueue_Top(VkDevice vkdevice,
+                        uint32_t family,
+                        uint32_t index,
+                        VkQueue* queue_out) {
+    const auto& table = GetDispatchTable(vkdevice);
+    table.GetDeviceQueue(vkdevice, family, index, queue_out);
+    hwvulkan_dispatch_t* queue_dispatch =
+        reinterpret_cast<hwvulkan_dispatch_t*>(*queue_out);
+    if (queue_dispatch->magic != HWVULKAN_DISPATCH_MAGIC &&
+        queue_dispatch->vtbl != &table)
+        ALOGE("invalid VkQueue dispatch magic: 0x%" PRIxPTR,
+              queue_dispatch->magic);
+    queue_dispatch->vtbl = &table;
 }
 
-VkResult AllocCommandBuffers(VkDevice device,
-                             const VkCommandBufferAllocateInfo* alloc_info,
-                             VkCommandBuffer* cmdbufs) {
-    const DeviceVtbl* vtbl = GetVtbl(device);
-    VkResult result = vtbl->AllocateCommandBuffers(device, alloc_info, cmdbufs);
+VkResult AllocateCommandBuffers_Top(
+    VkDevice vkdevice,
+    const VkCommandBufferAllocateInfo* alloc_info,
+    VkCommandBuffer* cmdbufs) {
+    const auto& table = GetDispatchTable(vkdevice);
+    VkResult result =
+        table.AllocateCommandBuffers(vkdevice, alloc_info, cmdbufs);
     if (result != VK_SUCCESS)
         return result;
-    for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
-        hwvulkan_dispatch_t* dispatch =
+    for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
+        hwvulkan_dispatch_t* cmdbuf_dispatch =
             reinterpret_cast<hwvulkan_dispatch_t*>(cmdbufs[i]);
-        ALOGE_IF(dispatch->magic != HWVULKAN_DISPATCH_MAGIC,
+        ALOGE_IF(cmdbuf_dispatch->magic != HWVULKAN_DISPATCH_MAGIC,
                  "invalid VkCommandBuffer dispatch magic: 0x%" PRIxPTR,
-                 dispatch->magic);
-        dispatch->vtbl = vtbl;
+                 cmdbuf_dispatch->magic);
+        cmdbuf_dispatch->vtbl = &table;
     }
     return VK_SUCCESS;
 }
 
-VkResult DestroyDevice(VkDevice drv_device,
+void DestroyDevice_Top(VkDevice vkdevice,
                        const VkAllocationCallbacks* /*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, device->instance->alloc);
-    DestroyDevice(device);
-    return VK_SUCCESS;
+    if (!vkdevice)
+        return;
+    Device& device = GetDispatchParent(vkdevice);
+    device.dispatch.DestroyDevice(vkdevice, device.instance->alloc);
+    DestroyDevice(&device);
 }
 
-void* AllocMem(VkInstance instance,
-               size_t size,
-               size_t align,
-               VkSystemAllocationScope scope) {
-    const VkAllocationCallbacks* alloc_cb = instance->alloc;
-    return alloc_cb->pfnAllocation(alloc_cb->pUserData, size, align, scope);
+// -----------------------------------------------------------------------------
+
+const VkAllocationCallbacks* GetAllocator(VkInstance vkinstance) {
+    return GetDispatchParent(vkinstance).alloc;
 }
 
-void FreeMem(VkInstance instance, void* ptr) {
-    const VkAllocationCallbacks* alloc_cb = instance->alloc;
-    alloc_cb->pfnFree(alloc_cb->pUserData, ptr);
+const VkAllocationCallbacks* GetAllocator(VkDevice vkdevice) {
+    return GetDispatchParent(vkdevice).instance->alloc;
 }
 
-void* AllocMem(VkDevice device,
-               size_t size,
-               size_t align,
-               VkSystemAllocationScope scope) {
-    const VkAllocationCallbacks* alloc_cb =
-        static_cast<Device*>(GetVtbl(device)->device)->instance->alloc;
-    return alloc_cb->pfnAllocation(alloc_cb->pUserData, size, align, scope);
+const DriverDispatchTable& GetDriverDispatch(VkDevice device) {
+    return GetDispatchParent(device).instance->drv.dispatch;
 }
 
-void FreeMem(VkDevice device, void* ptr) {
-    const VkAllocationCallbacks* alloc_cb =
-        static_cast<Device*>(GetVtbl(device)->device)->instance->alloc;
-    alloc_cb->pfnFree(alloc_cb->pUserData, ptr);
-}
-
-const DeviceVtbl& GetDriverVtbl(VkDevice device) {
-    // TODO(jessehall): This actually returns the API-level vtbl for the
-    // device, not the driver entry points. Given the current use -- getting
-    // the driver's private swapchain-related functions -- that works, but is
-    // misleading and likely to cause bugs. Fix as part of separating the
-    // loader->driver interface from the app->loader interface.
-    return static_cast<Device*>(GetVtbl(device)->device)->vtbl_storage;
-}
-
-const DeviceVtbl& GetDriverVtbl(VkQueue queue) {
-    // TODO(jessehall): This actually returns the API-level vtbl for the
-    // device, not the driver entry points. Given the current use -- getting
-    // the driver's private swapchain-related functions -- that works, but is
-    // misleading and likely to cause bugs. Fix as part of separating the
-    // loader->driver interface from the app->loader interface.
-    return static_cast<Device*>(GetVtbl(queue)->device)->vtbl_storage;
+const DriverDispatchTable& GetDriverDispatch(VkQueue queue) {
+    return GetDispatchParent(queue).instance->drv.dispatch;
 }
 
 }  // namespace vulkan
diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
index 1f777fc..6e32785 100644
--- a/vulkan/libvulkan/loader.h
+++ b/vulkan/libvulkan/loader.h
@@ -17,295 +17,134 @@
 #ifndef LIBVULKAN_LOADER_H
 #define LIBVULKAN_LOADER_H 1
 
-#define VK_PROTOTYPES
-#define VK_USE_PLATFORM_ANDROID_KHR
-#include <vulkan/vulkan.h>
-#include <vulkan/vk_android_native_buffer.h>
+#include "dispatch_gen.h"
 
 namespace vulkan {
 
-// TODO(jessehall): The InstanceVtbl and DeviceVtbl both have a set of
-// functions used in the app->layers/loader interface, and a different set of
-// functions used only in the loader->driver interface. We should probably
-// split them into two structures: one used for dispatch of application calls,
-// and one to hold the driver entry points.
+inline const InstanceDispatchTable& GetDispatchTable(VkInstance instance) {
+    return **reinterpret_cast<InstanceDispatchTable**>(instance);
+}
 
-struct InstanceVtbl {
-    // clang-format off
-    VkInstance instance;
+inline const InstanceDispatchTable& GetDispatchTable(
+    VkPhysicalDevice physical_device) {
+    return **reinterpret_cast<InstanceDispatchTable**>(physical_device);
+}
 
-    PFN_vkCreateInstance CreateInstance;
-    PFN_vkDestroyInstance DestroyInstance;
-    PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
-    PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
+inline const DeviceDispatchTable& GetDispatchTable(VkDevice device) {
+    return **reinterpret_cast<DeviceDispatchTable**>(device);
+}
 
-    PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
-    PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
-    PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
-    PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
-    PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
-    PFN_vkCreateDevice CreateDevice;
-    PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
-    PFN_vkEnumerateDeviceLayerProperties EnumerateDeviceLayerProperties;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
+inline const DeviceDispatchTable& GetDispatchTable(VkQueue queue) {
+    return **reinterpret_cast<DeviceDispatchTable**>(queue);
+}
 
-    // 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;
-    // clang-format on
-};
+inline const DeviceDispatchTable& GetDispatchTable(
+    VkCommandBuffer command_buffer) {
+    return **reinterpret_cast<DeviceDispatchTable**>(command_buffer);
+}
 
-struct DeviceVtbl {
-    void* device;
+// -----------------------------------------------------------------------------
+// dispatch_gen.cpp
 
-    PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
-    PFN_vkDestroyDevice DestroyDevice;
-    PFN_vkGetDeviceQueue GetDeviceQueue;
-    PFN_vkDeviceWaitIdle DeviceWaitIdle;
-    PFN_vkAllocateMemory AllocateMemory;
-    PFN_vkFreeMemory FreeMemory;
-    PFN_vkMapMemory MapMemory;
-    PFN_vkUnmapMemory UnmapMemory;
-    PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges;
-    PFN_vkInvalidateMappedMemoryRanges InvalidateMappedMemoryRanges;
-    PFN_vkGetDeviceMemoryCommitment GetDeviceMemoryCommitment;
-    PFN_vkBindBufferMemory BindBufferMemory;
-    PFN_vkBindImageMemory BindImageMemory;
-    PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements;
-    PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements;
-    PFN_vkGetImageSparseMemoryRequirements GetImageSparseMemoryRequirements;
-    PFN_vkCreateFence CreateFence;
-    PFN_vkDestroyFence DestroyFence;
-    PFN_vkResetFences ResetFences;
-    PFN_vkGetFenceStatus GetFenceStatus;
-    PFN_vkWaitForFences WaitForFences;
-    PFN_vkCreateSemaphore CreateSemaphore;
-    PFN_vkDestroySemaphore DestroySemaphore;
-    PFN_vkCreateEvent CreateEvent;
-    PFN_vkDestroyEvent DestroyEvent;
-    PFN_vkGetEventStatus GetEventStatus;
-    PFN_vkSetEvent SetEvent;
-    PFN_vkResetEvent ResetEvent;
-    PFN_vkCreateQueryPool CreateQueryPool;
-    PFN_vkDestroyQueryPool DestroyQueryPool;
-    PFN_vkGetQueryPoolResults GetQueryPoolResults;
-    PFN_vkCreateBuffer CreateBuffer;
-    PFN_vkDestroyBuffer DestroyBuffer;
-    PFN_vkCreateBufferView CreateBufferView;
-    PFN_vkDestroyBufferView DestroyBufferView;
-    PFN_vkCreateImage CreateImage;
-    PFN_vkDestroyImage DestroyImage;
-    PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout;
-    PFN_vkCreateImageView CreateImageView;
-    PFN_vkDestroyImageView DestroyImageView;
-    PFN_vkCreateShaderModule CreateShaderModule;
-    PFN_vkDestroyShaderModule DestroyShaderModule;
-    PFN_vkCreatePipelineCache CreatePipelineCache;
-    PFN_vkDestroyPipelineCache DestroyPipelineCache;
-    PFN_vkGetPipelineCacheData GetPipelineCacheData;
-    PFN_vkMergePipelineCaches MergePipelineCaches;
-    PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines;
-    PFN_vkCreateComputePipelines CreateComputePipelines;
-    PFN_vkDestroyPipeline DestroyPipeline;
-    PFN_vkCreatePipelineLayout CreatePipelineLayout;
-    PFN_vkDestroyPipelineLayout DestroyPipelineLayout;
-    PFN_vkCreateSampler CreateSampler;
-    PFN_vkDestroySampler DestroySampler;
-    PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout;
-    PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout;
-    PFN_vkCreateDescriptorPool CreateDescriptorPool;
-    PFN_vkDestroyDescriptorPool DestroyDescriptorPool;
-    PFN_vkResetDescriptorPool ResetDescriptorPool;
-    PFN_vkAllocateDescriptorSets AllocateDescriptorSets;
-    PFN_vkFreeDescriptorSets FreeDescriptorSets;
-    PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
-    PFN_vkCreateFramebuffer CreateFramebuffer;
-    PFN_vkDestroyFramebuffer DestroyFramebuffer;
-    PFN_vkCreateRenderPass CreateRenderPass;
-    PFN_vkDestroyRenderPass DestroyRenderPass;
-    PFN_vkGetRenderAreaGranularity GetRenderAreaGranularity;
-    PFN_vkCreateCommandPool CreateCommandPool;
-    PFN_vkDestroyCommandPool DestroyCommandPool;
-    PFN_vkResetCommandPool ResetCommandPool;
-    PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
-    PFN_vkFreeCommandBuffers FreeCommandBuffers;
-
-    PFN_vkQueueSubmit QueueSubmit;
-    PFN_vkQueueWaitIdle QueueWaitIdle;
-    PFN_vkQueueBindSparse QueueBindSparse;
-
-    PFN_vkBeginCommandBuffer BeginCommandBuffer;
-    PFN_vkEndCommandBuffer EndCommandBuffer;
-    PFN_vkResetCommandBuffer ResetCommandBuffer;
-    PFN_vkCmdBindPipeline CmdBindPipeline;
-    PFN_vkCmdSetViewport CmdSetViewport;
-    PFN_vkCmdSetScissor CmdSetScissor;
-    PFN_vkCmdSetLineWidth CmdSetLineWidth;
-    PFN_vkCmdSetDepthBias CmdSetDepthBias;
-    PFN_vkCmdSetBlendConstants CmdSetBlendConstants;
-    PFN_vkCmdSetDepthBounds CmdSetDepthBounds;
-    PFN_vkCmdSetStencilCompareMask CmdSetStencilCompareMask;
-    PFN_vkCmdSetStencilWriteMask CmdSetStencilWriteMask;
-    PFN_vkCmdSetStencilReference CmdSetStencilReference;
-    PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets;
-    PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer;
-    PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers;
-    PFN_vkCmdDraw CmdDraw;
-    PFN_vkCmdDrawIndexed CmdDrawIndexed;
-    PFN_vkCmdDrawIndirect CmdDrawIndirect;
-    PFN_vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect;
-    PFN_vkCmdDispatch CmdDispatch;
-    PFN_vkCmdDispatchIndirect CmdDispatchIndirect;
-    PFN_vkCmdCopyBuffer CmdCopyBuffer;
-    PFN_vkCmdCopyImage CmdCopyImage;
-    PFN_vkCmdBlitImage CmdBlitImage;
-    PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage;
-    PFN_vkCmdCopyImageToBuffer CmdCopyImageToBuffer;
-    PFN_vkCmdUpdateBuffer CmdUpdateBuffer;
-    PFN_vkCmdFillBuffer CmdFillBuffer;
-    PFN_vkCmdClearColorImage CmdClearColorImage;
-    PFN_vkCmdClearDepthStencilImage CmdClearDepthStencilImage;
-    PFN_vkCmdClearAttachments CmdClearAttachments;
-    PFN_vkCmdResolveImage CmdResolveImage;
-    PFN_vkCmdSetEvent CmdSetEvent;
-    PFN_vkCmdResetEvent CmdResetEvent;
-    PFN_vkCmdWaitEvents CmdWaitEvents;
-    PFN_vkCmdPipelineBarrier CmdPipelineBarrier;
-    PFN_vkCmdBeginQuery CmdBeginQuery;
-    PFN_vkCmdEndQuery CmdEndQuery;
-    PFN_vkCmdResetQueryPool CmdResetQueryPool;
-    PFN_vkCmdWriteTimestamp CmdWriteTimestamp;
-    PFN_vkCmdCopyQueryPoolResults CmdCopyQueryPoolResults;
-    PFN_vkCmdPushConstants CmdPushConstants;
-    PFN_vkCmdBeginRenderPass CmdBeginRenderPass;
-    PFN_vkCmdNextSubpass CmdNextSubpass;
-    PFN_vkCmdEndRenderPass CmdEndRenderPass;
-    PFN_vkCmdExecuteCommands CmdExecuteCommands;
-
-    // Layers and loader only, not implemented by drivers
-    PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
-    PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
-    PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
-    PFN_vkAcquireNextImageKHR AcquireNextImageKHR;
-    PFN_vkQueuePresentKHR QueuePresentKHR;
-
-    // Implemented only by drivers, not by layers or the loader
-    PFN_vkGetSwapchainGrallocUsageANDROID GetSwapchainGrallocUsageANDROID;
-    PFN_vkAcquireImageANDROID AcquireImageANDROID;
-    PFN_vkQueueSignalReleaseImageANDROID QueueSignalReleaseImageANDROID;
-    PFN_vkImportNativeFenceANDROID ImportNativeFenceANDROID;
-    PFN_vkQueueSignalNativeFenceANDROID QueueSignalNativeFenceANDROID;
-};
+PFN_vkVoidFunction GetLoaderExportProcAddr(const char* name);
+PFN_vkVoidFunction GetLoaderGlobalProcAddr(const char* name);
+PFN_vkVoidFunction GetLoaderTopProcAddr(const char* name);
+PFN_vkVoidFunction GetLoaderBottomProcAddr(const char* name);
+PFN_vkVoidFunction GetDispatchProcAddr(const InstanceDispatchTable& dispatch,
+                                       const char* name);
+PFN_vkVoidFunction GetDispatchProcAddr(const DeviceDispatchTable& dispatch,
+                                       const char* name);
+bool LoadInstanceDispatchTable(VkInstance instance,
+                               PFN_vkGetInstanceProcAddr get_proc_addr,
+                               InstanceDispatchTable& dispatch);
+bool LoadDeviceDispatchTable(VkDevice device,
+                             PFN_vkGetDeviceProcAddr get_proc_addr,
+                             DeviceDispatchTable& dispatch);
+bool LoadDriverDispatchTable(VkInstance instance,
+                             PFN_vkGetInstanceProcAddr get_proc_addr,
+                             DriverDispatchTable& dispatch);
 
 // -----------------------------------------------------------------------------
 // loader.cpp
 
-VkResult EnumerateInstanceExtensionProperties(
-    const char* layer_name,
-    uint32_t* count,
-    VkExtensionProperties* properties);
-VkResult EnumerateInstanceLayerProperties(uint32_t* count,
-                                          VkLayerProperties* properties);
-VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
-                        const VkAllocationCallbacks* allocator,
-                        VkInstance* instance);
-PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name);
-PFN_vkVoidFunction GetDeviceProcAddr(VkDevice drv_device, const char* name);
-void GetDeviceQueue(VkDevice drv_device,
-                    uint32_t family,
-                    uint32_t index,
-                    VkQueue* out_queue);
-VkResult AllocCommandBuffers(VkDevice device,
-                             const VkCommandBufferAllocateInfo* alloc_info,
-                             VkCommandBuffer* cmdbufs);
-VkResult DestroyDevice(VkDevice drv_device,
-                       const VkAllocationCallbacks* allocator);
+// clang-format off
+VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties_Top(const char* layer_name, uint32_t* count, VkExtensionProperties* properties);
+VKAPI_ATTR VkResult EnumerateInstanceLayerProperties_Top(uint32_t* count, VkLayerProperties* properties);
+VKAPI_ATTR VkResult CreateInstance_Top(const VkInstanceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkInstance* instance_out);
+VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr_Top(VkInstance instance, const char* name);
+VKAPI_ATTR void DestroyInstance_Top(VkInstance instance, const VkAllocationCallbacks* allocator);
+VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr_Top(VkDevice drv_device, const char* name);
+VKAPI_ATTR void GetDeviceQueue_Top(VkDevice drv_device, uint32_t family, uint32_t index, VkQueue* out_queue);
+VKAPI_ATTR VkResult AllocateCommandBuffers_Top(VkDevice device, const VkCommandBufferAllocateInfo* alloc_info, VkCommandBuffer* cmdbufs);
+VKAPI_ATTR void DestroyDevice_Top(VkDevice drv_device, const VkAllocationCallbacks* allocator);
 
-void* AllocMem(VkInstance instance,
-               size_t size,
-               size_t align,
-               VkSystemAllocationScope scope);
-void FreeMem(VkInstance instance, void* ptr);
-void* AllocMem(VkDevice device,
-               size_t size,
-               size_t align,
-               VkSystemAllocationScope scope);
-void FreeMem(VkDevice device, void* ptr);
-const DeviceVtbl& GetDriverVtbl(VkDevice device);
-const DeviceVtbl& GetDriverVtbl(VkQueue queue);
+VKAPI_ATTR VkResult CreateInstance_Bottom(const VkInstanceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkInstance* vkinstance);
+VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr_Bottom(VkInstance, const char* name);
+VKAPI_ATTR VkResult EnumeratePhysicalDevices_Bottom(VkInstance vkinstance, uint32_t* pdev_count, VkPhysicalDevice* pdevs);
+VKAPI_ATTR void GetPhysicalDeviceProperties_Bottom(VkPhysicalDevice pdev, VkPhysicalDeviceProperties* properties);
+VKAPI_ATTR void GetPhysicalDeviceFeatures_Bottom(VkPhysicalDevice pdev, VkPhysicalDeviceFeatures* features);
+VKAPI_ATTR void GetPhysicalDeviceMemoryProperties_Bottom(VkPhysicalDevice pdev, VkPhysicalDeviceMemoryProperties* properties);
+VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties_Bottom(VkPhysicalDevice pdev, uint32_t* properties_count, VkQueueFamilyProperties* properties);
+VKAPI_ATTR void GetPhysicalDeviceFormatProperties_Bottom(VkPhysicalDevice pdev, VkFormat format, VkFormatProperties* properties);
+VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties_Bottom(VkPhysicalDevice pdev, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* properties);
+VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties_Bottom(VkPhysicalDevice pdev, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* properties_count, VkSparseImageFormatProperties* properties);
+VKAPI_ATTR VkResult EnumerateDeviceExtensionProperties_Bottom(VkPhysicalDevice pdev, const char* layer_name, uint32_t* properties_count, VkExtensionProperties* properties);
+VKAPI_ATTR VkResult EnumerateDeviceLayerProperties_Bottom(VkPhysicalDevice pdev, uint32_t* properties_count, VkLayerProperties* properties);
+VKAPI_ATTR VkResult CreateDevice_Bottom(VkPhysicalDevice pdev, const VkDeviceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkDevice* device_out);
+VKAPI_ATTR void DestroyInstance_Bottom(VkInstance vkinstance, const VkAllocationCallbacks* allocator);
+VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr_Bottom(VkDevice vkdevice, const char* name);
+// clang-format on
 
-// -----------------------------------------------------------------------------
-// get_proc_addr.cpp
-
-PFN_vkVoidFunction GetGlobalInstanceProcAddr(const char* name);
-PFN_vkVoidFunction GetGlobalDeviceProcAddr(const char* name);
-PFN_vkVoidFunction GetSpecificInstanceProcAddr(const InstanceVtbl* vtbl,
-                                               const char* name);
-PFN_vkVoidFunction GetSpecificDeviceProcAddr(const DeviceVtbl* vtbl,
-                                             const char* name);
-
-bool LoadInstanceVtbl(VkInstance instance,
-                      VkInstance next_instance,
-                      PFN_vkGetInstanceProcAddr get_proc_addr,
-                      InstanceVtbl& vtbl);
-bool LoadDeviceVtbl(VkDevice device,
-                    VkDevice next_device,
-                    PFN_vkGetDeviceProcAddr get_proc_addr,
-                    DeviceVtbl& vtbl);
+const VkAllocationCallbacks* GetAllocator(VkInstance instance);
+const VkAllocationCallbacks* GetAllocator(VkDevice device);
+const DriverDispatchTable& GetDriverDispatch(VkDevice device);
+const DriverDispatchTable& GetDriverDispatch(VkQueue queue);
 
 // -----------------------------------------------------------------------------
 // swapchain.cpp
 
-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,
-                                                       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,
-                   const VkAllocationCallbacks* allocator,
-                   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,
-                                          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, const VkPresentInfoKHR* present_info);
+// clang-format off
+VKAPI_ATTR VkResult CreateAndroidSurfaceKHR_Bottom(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface);
+VKAPI_ATTR void DestroySurfaceKHR_Bottom(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* allocator);
+VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceSupportKHR_Bottom(VkPhysicalDevice pdev, uint32_t queue_family, VkSurfaceKHR surface, VkBool32* pSupported);
+VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR_Bottom(VkPhysicalDevice pdev, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* capabilities);
+VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceFormatsKHR_Bottom(VkPhysicalDevice pdev, VkSurfaceKHR surface, uint32_t* count, VkSurfaceFormatKHR* formats);
+VKAPI_ATTR VkResult GetPhysicalDeviceSurfacePresentModesKHR_Bottom(VkPhysicalDevice pdev, VkSurfaceKHR surface, uint32_t* count, VkPresentModeKHR* modes);
+VKAPI_ATTR VkResult CreateSwapchainKHR_Bottom(VkDevice device, const VkSwapchainCreateInfoKHR* create_info, const VkAllocationCallbacks* allocator, VkSwapchainKHR* swapchain_handle);
+VKAPI_ATTR void DestroySwapchainKHR_Bottom(VkDevice device, VkSwapchainKHR swapchain_handle, const VkAllocationCallbacks* allocator);
+VKAPI_ATTR VkResult GetSwapchainImagesKHR_Bottom(VkDevice device, VkSwapchainKHR swapchain_handle, uint32_t* count, VkImage* images);
+VKAPI_ATTR VkResult AcquireNextImageKHR_Bottom(VkDevice device, VkSwapchainKHR swapchain_handle, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* image_index);
+VKAPI_ATTR VkResult QueuePresentKHR_Bottom(VkQueue queue, const VkPresentInfoKHR* present_info);
+// clang-format on
+
+// -----------------------------------------------------------------------------
+// layers_extensions.cpp
+
+struct Layer;
+class LayerRef {
+   public:
+    LayerRef(Layer* layer);
+    LayerRef(LayerRef&& other);
+    ~LayerRef();
+    LayerRef(const LayerRef&) = delete;
+    LayerRef& operator=(const LayerRef&) = delete;
+
+    // provides bool-like behavior
+    operator const Layer*() const { return layer_; }
+
+    PFN_vkGetInstanceProcAddr GetGetInstanceProcAddr() const;
+    PFN_vkGetDeviceProcAddr GetGetDeviceProcAddr() const;
+
+   private:
+    Layer* layer_;
+};
+
+void DiscoverLayers();
+uint32_t EnumerateLayers(uint32_t count, VkLayerProperties* properties);
+void GetLayerExtensions(const char* name,
+                        const VkExtensionProperties** properties,
+                        uint32_t* count);
+LayerRef GetLayerRef(const char* name);
 
 }  // namespace vulkan
 
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index 39a581c..2bad1bb 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -65,34 +65,40 @@
         VK_SYSTEM_ALLOCATION_SCOPE_DEVICE;
 };
 
-template <typename T, typename Host>
+template <typename T>
 class VulkanAllocator {
    public:
     typedef T value_type;
 
-    explicit VulkanAllocator(Host host) : host_(host) {}
+    VulkanAllocator(const VkAllocationCallbacks& allocator,
+                    VkSystemAllocationScope scope)
+        : allocator_(allocator), scope_(scope) {}
 
     template <typename U>
-    explicit VulkanAllocator(const VulkanAllocator<U, Host>& other)
-        : host_(other.host_) {}
+    explicit VulkanAllocator(const VulkanAllocator<U>& other)
+        : allocator_(other.allocator_), scope_(other.scope_) {}
 
     T* allocate(size_t n) const {
-        return static_cast<T*>(AllocMem(host_, n * sizeof(T), alignof(T),
-                                        AllocScope<Host>::kScope));
+        return static_cast<T*>(allocator_.pfnAllocation(
+            allocator_.pUserData, n * sizeof(T), alignof(T), scope_));
     }
-    void deallocate(T* p, size_t) const { return FreeMem(host_, p); }
+    void deallocate(T* p, size_t) const {
+        return allocator_.pfnFree(allocator_.pUserData, p);
+    }
 
    private:
-    template <typename U, typename H>
+    template <typename U>
     friend class VulkanAllocator;
-    Host host_;
+    const VkAllocationCallbacks& allocator_;
+    const VkSystemAllocationScope scope_;
 };
 
 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, Host>(host));
+    return std::shared_ptr<T>(
+        obj, NativeBaseDeleter<T>(),
+        VulkanAllocator<T>(*GetAllocator(host), AllocScope<Host>::kScope));
 }
 
 // ----------------------------------------------------------------------------
@@ -142,17 +148,21 @@
 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);
+VkResult CreateAndroidSurfaceKHR_Bottom(
+    VkInstance instance,
+    const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+    const VkAllocationCallbacks* allocator,
+    VkSurfaceKHR* out_surface) {
+    if (!allocator)
+        allocator = GetAllocator(instance);
+    void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Surface),
+                                         alignof(Surface),
+                                         VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
     if (!mem)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     Surface* surface = new (mem) Surface;
 
-    surface->window = InitSharedPtr(instance, window);
+    surface->window = InitSharedPtr(instance, pCreateInfo->window);
 
     // TODO(jessehall): Create and use NATIVE_WINDOW_API_VULKAN.
     int err =
@@ -163,7 +173,7 @@
         ALOGE("native_window_api_connect() failed: %s (%d)", strerror(-err),
               err);
         surface->~Surface();
-        FreeMem(instance, surface);
+        allocator->pfnFree(allocator->pUserData, surface);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
@@ -172,28 +182,30 @@
 }
 
 VKAPI_ATTR
-void DestroySurfaceKHR(VkInstance instance,
-                       VkSurfaceKHR surface_handle,
-                       const VkAllocationCallbacks* /*allocator*/) {
+void DestroySurfaceKHR_Bottom(VkInstance instance,
+                              VkSurfaceKHR surface_handle,
+                              const VkAllocationCallbacks* allocator) {
     Surface* surface = SurfaceFromHandle(surface_handle);
     if (!surface)
         return;
     native_window_api_disconnect(surface->window.get(), NATIVE_WINDOW_API_EGL);
     surface->~Surface();
-    FreeMem(instance, surface);
+    if (!allocator)
+        allocator = GetAllocator(instance);
+    allocator->pfnFree(allocator->pUserData, surface);
 }
 
 VKAPI_ATTR
-VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
-                                            uint32_t /*queue_family*/,
-                                            VkSurfaceKHR /*surface*/,
-                                            VkBool32* supported) {
+VkResult GetPhysicalDeviceSurfaceSupportKHR_Bottom(VkPhysicalDevice /*pdev*/,
+                                                   uint32_t /*queue_family*/,
+                                                   VkSurfaceKHR /*surface*/,
+                                                   VkBool32* supported) {
     *supported = VK_TRUE;
     return VK_SUCCESS;
 }
 
 VKAPI_ATTR
-VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
+VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR_Bottom(
     VkPhysicalDevice /*pdev*/,
     VkSurfaceKHR surface,
     VkSurfaceCapabilitiesKHR* capabilities) {
@@ -214,7 +226,8 @@
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
-    capabilities->currentExtent = VkExtent2D{width, height};
+    capabilities->currentExtent =
+        VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
 
     // TODO(jessehall): Figure out what the min/max values should be.
     capabilities->minImageCount = 2;
@@ -227,10 +240,10 @@
 
     // TODO(jessehall): We can support all transforms, fix this once
     // implemented.
-    capabilities->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_KHR;
+    capabilities->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
 
     // TODO(jessehall): Implement based on NATIVE_WINDOW_TRANSFORM_HINT.
-    capabilities->currentTransform = VK_SURFACE_TRANSFORM_NONE_BIT_KHR;
+    capabilities->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
 
     capabilities->maxImageArrayLayers = 1;
 
@@ -250,10 +263,11 @@
 }
 
 VKAPI_ATTR
-VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice /*pdev*/,
-                                            VkSurfaceKHR /*surface*/,
-                                            uint32_t* count,
-                                            VkSurfaceFormatKHR* formats) {
+VkResult GetPhysicalDeviceSurfaceFormatsKHR_Bottom(
+    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
@@ -277,10 +291,11 @@
 }
 
 VKAPI_ATTR
-VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice /*pdev*/,
-                                                 VkSurfaceKHR /*surface*/,
-                                                 uint32_t* count,
-                                                 VkPresentModeKHR* modes) {
+VkResult GetPhysicalDeviceSurfacePresentModesKHR_Bottom(
+    VkPhysicalDevice /*pdev*/,
+    VkSurfaceKHR /*surface*/,
+    uint32_t* count,
+    VkPresentModeKHR* modes) {
     const VkPresentModeKHR kModes[] = {
         VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR,
     };
@@ -297,13 +312,16 @@
 }
 
 VKAPI_ATTR
-VkResult CreateSwapchainKHR(VkDevice device,
-                            const VkSwapchainCreateInfoKHR* create_info,
-                            const VkAllocationCallbacks* /*allocator*/,
-                            VkSwapchainKHR* swapchain_handle) {
+VkResult CreateSwapchainKHR_Bottom(VkDevice device,
+                                   const VkSwapchainCreateInfoKHR* create_info,
+                                   const VkAllocationCallbacks* allocator,
+                                   VkSwapchainKHR* swapchain_handle) {
     int err;
     VkResult result = VK_SUCCESS;
 
+    if (!allocator)
+        allocator = GetAllocator(device);
+
     ALOGV_IF(create_info->imageArraySize != 1,
              "Swapchain imageArraySize (%u) != 1 not supported",
              create_info->imageArraySize);
@@ -314,7 +332,7 @@
              "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_BIT_KHR,
+    ALOGE_IF(create_info->preTransform != VK_SURFACE_TRANSFORM_IDENTITY_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");
@@ -322,11 +340,11 @@
     // -- Configure the native window --
 
     Surface& surface = *SurfaceFromHandle(create_info->surface);
-    const DeviceVtbl& driver_vtbl = GetDriverVtbl(device);
+    const DriverDispatchTable& dispatch = GetDriverDispatch(device);
 
-    err = native_window_set_buffers_dimensions(surface.window.get(),
-                                               create_info->imageExtent.width,
-                                               create_info->imageExtent.height);
+    err = native_window_set_buffers_dimensions(
+        surface.window.get(), static_cast<int>(create_info->imageExtent.width),
+        static_cast<int>(create_info->imageExtent.height));
     if (err != 0) {
         // TODO(jessehall): Improve error reporting. Can we enumerate possible
         // errors and translate them to valid Vulkan result codes?
@@ -369,8 +387,8 @@
 
     int gralloc_usage = 0;
     // TODO(jessehall): Remove conditional once all drivers have been updated
-    if (driver_vtbl.GetSwapchainGrallocUsageANDROID) {
-        result = driver_vtbl.GetSwapchainGrallocUsageANDROID(
+    if (dispatch.GetSwapchainGrallocUsageANDROID) {
+        result = dispatch.GetSwapchainGrallocUsageANDROID(
             device, create_info->imageFormat, create_info->imageUsage,
             &gralloc_usage);
         if (result != VK_SUCCESS) {
@@ -391,8 +409,9 @@
     // -- Allocate our Swapchain object --
     // After this point, we must deallocate the swapchain on error.
 
-    void* mem = AllocMem(device, sizeof(Swapchain), alignof(Swapchain),
-                         VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+    void* mem = allocator->pfnAllocation(allocator->pUserData,
+                                         sizeof(Swapchain), alignof(Swapchain),
+                                         VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
     if (!mem)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     Swapchain* swapchain = new (mem) Swapchain(surface, num_images);
@@ -401,7 +420,6 @@
     // Any failures during or after this must cancel the dequeued buffers.
 
     VkNativeBufferANDROID image_native_buffer = {
-// TODO(jessehall): Figure out how to make extension headers not horrible.
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wold-style-cast"
         .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
@@ -442,14 +460,16 @@
         img.dequeued = true;
 
         image_create.extent =
-            VkExtent3D{img.buffer->width, img.buffer->height, 1};
+            VkExtent3D{static_cast<uint32_t>(img.buffer->width),
+                       static_cast<uint32_t>(img.buffer->height),
+                       1};
         image_native_buffer.handle = img.buffer->handle;
         image_native_buffer.stride = img.buffer->stride;
         image_native_buffer.format = img.buffer->format;
         image_native_buffer.usage = img.buffer->usage;
 
         result =
-            driver_vtbl.CreateImage(device, &image_create, nullptr, &img.image);
+            dispatch.CreateImage(device, &image_create, nullptr, &img.image);
         if (result != VK_SUCCESS) {
             ALOGD("vkCreateImage w/ native buffer failed: %u", result);
             break;
@@ -472,13 +492,13 @@
         }
         if (result != VK_SUCCESS) {
             if (img.image)
-                driver_vtbl.DestroyImage(device, img.image, nullptr);
+                dispatch.DestroyImage(device, img.image, nullptr);
         }
     }
 
     if (result != VK_SUCCESS) {
         swapchain->~Swapchain();
-        FreeMem(device, swapchain);
+        allocator->pfnFree(allocator->pUserData, swapchain);
         return result;
     }
 
@@ -487,10 +507,10 @@
 }
 
 VKAPI_ATTR
-VkResult DestroySwapchainKHR(VkDevice device,
-                             VkSwapchainKHR swapchain_handle,
-                             const VkAllocationCallbacks* /*allocator*/) {
-    const DeviceVtbl& driver_vtbl = GetDriverVtbl(device);
+void DestroySwapchainKHR_Bottom(VkDevice device,
+                                VkSwapchainKHR swapchain_handle,
+                                const VkAllocationCallbacks* allocator) {
+    const DriverDispatchTable& dispatch = GetDriverDispatch(device);
     Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
     const std::shared_ptr<ANativeWindow>& window = swapchain->surface.window;
 
@@ -503,21 +523,21 @@
             img.dequeued = false;
         }
         if (img.image) {
-            driver_vtbl.DestroyImage(device, img.image, nullptr);
+            dispatch.DestroyImage(device, img.image, nullptr);
         }
     }
 
+    if (!allocator)
+        allocator = GetAllocator(device);
     swapchain->~Swapchain();
-    FreeMem(device, swapchain);
-
-    return VK_SUCCESS;
+    allocator->pfnFree(allocator->pUserData, swapchain);
 }
 
 VKAPI_ATTR
-VkResult GetSwapchainImagesKHR(VkDevice,
-                               VkSwapchainKHR swapchain_handle,
-                               uint32_t* count,
-                               VkImage* images) {
+VkResult GetSwapchainImagesKHR_Bottom(VkDevice,
+                                      VkSwapchainKHR swapchain_handle,
+                                      uint32_t* count,
+                                      VkImage* images) {
     Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
     VkResult result = VK_SUCCESS;
     if (images) {
@@ -534,11 +554,12 @@
 }
 
 VKAPI_ATTR
-VkResult AcquireNextImageKHR(VkDevice device,
-                             VkSwapchainKHR swapchain_handle,
-                             uint64_t timeout,
-                             VkSemaphore semaphore,
-                             uint32_t* image_index) {
+VkResult AcquireNextImageKHR_Bottom(VkDevice device,
+                                    VkSwapchainKHR swapchain_handle,
+                                    uint64_t timeout,
+                                    VkSemaphore semaphore,
+                                    VkFence vk_fence,
+                                    uint32_t* image_index) {
     Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
     ANativeWindow* window = swapchain.surface.window.get();
     VkResult result;
@@ -549,8 +570,8 @@
         "vkAcquireNextImageKHR: non-infinite timeouts not yet implemented");
 
     ANativeWindowBuffer* buffer;
-    int fence;
-    err = window->dequeueBuffer(window, &buffer, &fence);
+    int fence_fd;
+    err = window->dequeueBuffer(window, &buffer, &fence_fd);
     if (err != 0) {
         // TODO(jessehall): Improve error reporting. Can we enumerate possible
         // errors and translate them to valid Vulkan result codes?
@@ -562,37 +583,28 @@
     for (idx = 0; idx < swapchain.num_images; idx++) {
         if (swapchain.images[idx].buffer.get() == buffer) {
             swapchain.images[idx].dequeued = true;
-            swapchain.images[idx].dequeue_fence = fence;
+            swapchain.images[idx].dequeue_fence = fence_fd;
             break;
         }
     }
     if (idx == swapchain.num_images) {
         ALOGE("dequeueBuffer returned unrecognized buffer");
-        window->cancelBuffer(window, buffer, fence);
+        window->cancelBuffer(window, buffer, fence_fd);
         return VK_ERROR_OUT_OF_DATE_KHR;
     }
 
     int fence_clone = -1;
-    if (fence != -1) {
-        fence_clone = dup(fence);
+    if (fence_fd != -1) {
+        fence_clone = dup(fence_fd);
         if (fence_clone == -1) {
             ALOGE("dup(fence) failed, stalling until signalled: %s (%d)",
                   strerror(errno), errno);
-            sync_wait(fence, -1 /* forever */);
+            sync_wait(fence_fd, -1 /* forever */);
         }
     }
 
-    const DeviceVtbl& driver_vtbl = GetDriverVtbl(device);
-    if (driver_vtbl.AcquireImageANDROID) {
-        result = driver_vtbl.AcquireImageANDROID(
-            device, swapchain.images[idx].image, fence_clone, semaphore);
-    } else {
-        ALOG_ASSERT(driver_vtbl.ImportNativeFenceANDROID,
-                    "Have neither vkAcquireImageANDROID nor "
-                    "vkImportNativeFenceANDROID");
-        result = driver_vtbl.ImportNativeFenceANDROID(device, semaphore,
-                                                      fence_clone);
-    }
+    result = GetDriverDispatch(device).AcquireImageANDROID(
+        device, swapchain.images[idx].image, fence_clone, semaphore, vk_fence);
     if (result != VK_SUCCESS) {
         // NOTE: we're relying on AcquireImageANDROID to close fence_clone,
         // even if the call fails. We could close it ourselves on failure, but
@@ -601,7 +613,7 @@
         // 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.
-        window->cancelBuffer(window, buffer, fence);
+        window->cancelBuffer(window, buffer, fence_fd);
         swapchain.images[idx].dequeued = false;
         swapchain.images[idx].dequeue_fence = -1;
         return result;
@@ -612,13 +624,14 @@
 }
 
 VKAPI_ATTR
-VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) {
+VkResult QueuePresentKHR_Bottom(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);
     ALOGV_IF(present_info->pNext, "VkPresentInfo::pNext != NULL");
 
-    const DeviceVtbl& driver_vtbl = GetDriverVtbl(queue);
+    const DriverDispatchTable& dispatch = GetDriverDispatch(queue);
     VkResult final_result = VK_SUCCESS;
     for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
         Swapchain& swapchain =
@@ -630,15 +643,8 @@
         int err;
 
         int fence = -1;
-        if (driver_vtbl.QueueSignalReleaseImageANDROID) {
-            result = driver_vtbl.QueueSignalReleaseImageANDROID(
-                queue, img.image, &fence);
-        } else {
-            ALOG_ASSERT(driver_vtbl.QueueSignalNativeFenceANDROID,
-                        "Have neither vkQueueSignalReleaseImageANDROID nor "
-                        "vkQueueSignalNativeFenceANDROID");
-            result = driver_vtbl.QueueSignalNativeFenceANDROID(queue, &fence);
-        }
+        result =
+            dispatch.QueueSignalReleaseImageANDROID(queue, img.image, &fence);
         if (result != VK_SUCCESS) {
             ALOGE("QueueSignalReleaseImageANDROID failed: %d", result);
             if (present_info->pResults)
diff --git a/vulkan/nulldrv/Android.mk b/vulkan/nulldrv/Android.mk
index b98ec20..2db6138 100644
--- a/vulkan/nulldrv/Android.mk
+++ b/vulkan/nulldrv/Android.mk
@@ -35,7 +35,8 @@
 
 LOCAL_SHARED_LIBRARIES := liblog
 
-LOCAL_MODULE := vulkan.$(TARGET_BOARD_PLATFORM)
+# Real drivers would set this to vulkan.$(TARGET_BOARD_PLATFORM)
+LOCAL_MODULE := vulkan.default
 LOCAL_PROPRIETARY_MODULE := true
 LOCAL_MODULE_RELATIVE_PATH := hw
 LOCAL_MODULE_TAGS := optional
diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
index 4fd0103..9a75697 100644
--- a/vulkan/nulldrv/null_driver.cpp
+++ b/vulkan/nulldrv/null_driver.cpp
@@ -16,16 +16,16 @@
 
 #include <hardware/hwvulkan.h>
 
-#include <array>
-#include <algorithm>
 #include <inttypes.h>
 #include <string.h>
+#include <algorithm>
+#include <array>
 
 // #define LOG_NDEBUG 0
 #include <log/log.h>
 #include <utils/Errors.h>
 
-#include "null_driver.h"
+#include "null_driver_gen.h"
 
 using namespace null_driver;
 
@@ -129,30 +129,6 @@
 
 namespace {
 
-VKAPI_ATTR
-VkResult CreateInstance(const VkInstanceCreateInfo* /*create_info*/,
-                        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->pfnAllocation(
-            allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
-            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE));
-    if (!instance)
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-
-    instance->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
-    instance->allocator = *allocator;
-    instance->physical_device.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
-
-    *out_instance = instance;
-    return VK_SUCCESS;
-}
-
 int CloseDevice(struct hw_device_t* /*device*/) {
     // nothing to do - opening a device doesn't allocate any resources
     return 0;
@@ -188,12 +164,14 @@
         offsetof(VkInstance_T, physical_device));
 }
 
-uint64_t AllocHandle(VkDevice device, HandleType::Enum type) {
+template <class Handle>
+Handle AllocHandle(VkDevice device, HandleType::Enum type) {
     const uint64_t kHandleMask = (UINT64_C(1) << 56) - 1;
     ALOGE_IF(device->next_handle[type] == kHandleMask,
              "non-dispatchable handles of type=%u are about to overflow", type);
-    return (UINT64_C(1) << 63) | ((uint64_t(type) & 0x7) << 56) |
-           (device->next_handle[type]++ & kHandleMask);
+    return reinterpret_cast<Handle>(
+        (UINT64_C(1) << 63) | ((uint64_t(type) & 0x7) << 56) |
+        (device->next_handle[type]++ & kHandleMask));
 }
 
 }  // namespace
@@ -222,27 +200,37 @@
 }
 
 VKAPI_ATTR
-PFN_vkVoidFunction GetInstanceProcAddr(VkInstance, const char* name) {
-    PFN_vkVoidFunction proc = LookupInstanceProcAddr(name);
-    if (!proc && strcmp(name, "vkGetDeviceProcAddr") == 0)
-        proc = reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr);
-    return proc;
+VkResult CreateInstance(const VkInstanceCreateInfo* /*create_info*/,
+                        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->pfnAllocation(
+            allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
+            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE));
+    if (!instance)
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+    instance->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
+    instance->allocator = *allocator;
+    instance->physical_device.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
+
+    *out_instance = instance;
+    return VK_SUCCESS;
+}
+
+VKAPI_ATTR
+PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
+    return instance ? GetInstanceProcAddr(name) : GetGlobalProcAddr(name);
 }
 
 VKAPI_ATTR
 PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) {
-    PFN_vkVoidFunction proc = LookupDeviceProcAddr(name);
-    if (proc)
-        return proc;
-    if (strcmp(name, "vkGetSwapchainGrallocUsageANDROID") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(
-            GetSwapchainGrallocUsageANDROID);
-    if (strcmp(name, "vkAcquireImageANDROID") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(AcquireImageANDROID);
-    if (strcmp(name, "vkQueueSignalReleaseImageANDROID") == 0)
-        return reinterpret_cast<PFN_vkVoidFunction>(
-            QueueSignalReleaseImageANDROID);
-    return nullptr;
+    return GetInstanceProcAddr(name);
 }
 
 // -----------------------------------------------------------------------------
@@ -383,8 +371,8 @@
                                 VkCommandBuffer* cmdbufs) {
     VkResult result = VK_SUCCESS;
     CommandPool& pool = *GetCommandPoolFromHandle(alloc_info->commandPool);
-    std::fill(cmdbufs, cmdbufs + alloc_info->bufferCount, nullptr);
-    for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
+    std::fill(cmdbufs, cmdbufs + alloc_info->commandBufferCount, nullptr);
+    for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
         cmdbufs[i] =
             static_cast<VkCommandBuffer_T*>(pool.allocator.pfnAllocation(
                 pool.allocator.pUserData, sizeof(VkCommandBuffer_T),
@@ -396,7 +384,7 @@
         cmdbufs[i]->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
     }
     if (result != VK_SUCCESS) {
-        for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
+        for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
             if (!cmdbufs[i])
                 break;
             pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
@@ -578,7 +566,7 @@
                           const VkBufferViewCreateInfo*,
                           const VkAllocationCallbacks* /*allocator*/,
                           VkBufferView* view) {
-    *view = AllocHandle(device, HandleType::kBufferView);
+    *view = AllocHandle<VkBufferView>(device, HandleType::kBufferView);
     return VK_SUCCESS;
 }
 
@@ -586,15 +574,16 @@
                               const VkDescriptorPoolCreateInfo*,
                               const VkAllocationCallbacks* /*allocator*/,
                               VkDescriptorPool* pool) {
-    *pool = AllocHandle(device, HandleType::kDescriptorPool);
+    *pool = AllocHandle<VkDescriptorPool>(device, HandleType::kDescriptorPool);
     return VK_SUCCESS;
 }
 
 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);
+    for (uint32_t i = 0; i < alloc_info->descriptorSetCount; i++)
+        descriptor_sets[i] =
+            AllocHandle<VkDescriptorSet>(device, HandleType::kDescriptorSet);
     return VK_SUCCESS;
 }
 
@@ -602,7 +591,8 @@
                                    const VkDescriptorSetLayoutCreateInfo*,
                                    const VkAllocationCallbacks* /*allocator*/,
                                    VkDescriptorSetLayout* layout) {
-    *layout = AllocHandle(device, HandleType::kDescriptorSetLayout);
+    *layout = AllocHandle<VkDescriptorSetLayout>(
+        device, HandleType::kDescriptorSetLayout);
     return VK_SUCCESS;
 }
 
@@ -610,7 +600,7 @@
                      const VkEventCreateInfo*,
                      const VkAllocationCallbacks* /*allocator*/,
                      VkEvent* event) {
-    *event = AllocHandle(device, HandleType::kEvent);
+    *event = AllocHandle<VkEvent>(device, HandleType::kEvent);
     return VK_SUCCESS;
 }
 
@@ -618,7 +608,7 @@
                      const VkFenceCreateInfo*,
                      const VkAllocationCallbacks* /*allocator*/,
                      VkFence* fence) {
-    *fence = AllocHandle(device, HandleType::kFence);
+    *fence = AllocHandle<VkFence>(device, HandleType::kFence);
     return VK_SUCCESS;
 }
 
@@ -626,7 +616,7 @@
                            const VkFramebufferCreateInfo*,
                            const VkAllocationCallbacks* /*allocator*/,
                            VkFramebuffer* framebuffer) {
-    *framebuffer = AllocHandle(device, HandleType::kFramebuffer);
+    *framebuffer = AllocHandle<VkFramebuffer>(device, HandleType::kFramebuffer);
     return VK_SUCCESS;
 }
 
@@ -634,7 +624,7 @@
                          const VkImageViewCreateInfo*,
                          const VkAllocationCallbacks* /*allocator*/,
                          VkImageView* view) {
-    *view = AllocHandle(device, HandleType::kImageView);
+    *view = AllocHandle<VkImageView>(device, HandleType::kImageView);
     return VK_SUCCESS;
 }
 
@@ -645,7 +635,7 @@
                                  const VkAllocationCallbacks* /*allocator*/,
                                  VkPipeline* pipelines) {
     for (uint32_t i = 0; i < count; i++)
-        pipelines[i] = AllocHandle(device, HandleType::kPipeline);
+        pipelines[i] = AllocHandle<VkPipeline>(device, HandleType::kPipeline);
     return VK_SUCCESS;
 }
 
@@ -656,7 +646,7 @@
                                 const VkAllocationCallbacks* /*allocator*/,
                                 VkPipeline* pipelines) {
     for (uint32_t i = 0; i < count; i++)
-        pipelines[i] = AllocHandle(device, HandleType::kPipeline);
+        pipelines[i] = AllocHandle<VkPipeline>(device, HandleType::kPipeline);
     return VK_SUCCESS;
 }
 
@@ -664,7 +654,7 @@
                              const VkPipelineCacheCreateInfo*,
                              const VkAllocationCallbacks* /*allocator*/,
                              VkPipelineCache* cache) {
-    *cache = AllocHandle(device, HandleType::kPipelineCache);
+    *cache = AllocHandle<VkPipelineCache>(device, HandleType::kPipelineCache);
     return VK_SUCCESS;
 }
 
@@ -672,7 +662,8 @@
                               const VkPipelineLayoutCreateInfo*,
                               const VkAllocationCallbacks* /*allocator*/,
                               VkPipelineLayout* layout) {
-    *layout = AllocHandle(device, HandleType::kPipelineLayout);
+    *layout =
+        AllocHandle<VkPipelineLayout>(device, HandleType::kPipelineLayout);
     return VK_SUCCESS;
 }
 
@@ -680,7 +671,7 @@
                          const VkQueryPoolCreateInfo*,
                          const VkAllocationCallbacks* /*allocator*/,
                          VkQueryPool* pool) {
-    *pool = AllocHandle(device, HandleType::kQueryPool);
+    *pool = AllocHandle<VkQueryPool>(device, HandleType::kQueryPool);
     return VK_SUCCESS;
 }
 
@@ -688,7 +679,7 @@
                           const VkRenderPassCreateInfo*,
                           const VkAllocationCallbacks* /*allocator*/,
                           VkRenderPass* renderpass) {
-    *renderpass = AllocHandle(device, HandleType::kRenderPass);
+    *renderpass = AllocHandle<VkRenderPass>(device, HandleType::kRenderPass);
     return VK_SUCCESS;
 }
 
@@ -696,7 +687,7 @@
                        const VkSamplerCreateInfo*,
                        const VkAllocationCallbacks* /*allocator*/,
                        VkSampler* sampler) {
-    *sampler = AllocHandle(device, HandleType::kSampler);
+    *sampler = AllocHandle<VkSampler>(device, HandleType::kSampler);
     return VK_SUCCESS;
 }
 
@@ -704,7 +695,7 @@
                          const VkSemaphoreCreateInfo*,
                          const VkAllocationCallbacks* /*allocator*/,
                          VkSemaphore* semaphore) {
-    *semaphore = AllocHandle(device, HandleType::kSemaphore);
+    *semaphore = AllocHandle<VkSemaphore>(device, HandleType::kSemaphore);
     return VK_SUCCESS;
 }
 
@@ -712,7 +703,7 @@
                             const VkShaderModuleCreateInfo*,
                             const VkAllocationCallbacks* /*allocator*/,
                             VkShaderModule* module) {
-    *module = AllocHandle(device, HandleType::kShaderModule);
+    *module = AllocHandle<VkShaderModule>(device, HandleType::kShaderModule);
     return VK_SUCCESS;
 }
 
@@ -725,7 +716,11 @@
     return VK_SUCCESS;
 }
 
-VkResult AcquireImageANDROID(VkDevice, VkImage, int fence, VkSemaphore) {
+VkResult AcquireImageANDROID(VkDevice,
+                             VkImage,
+                             int fence,
+                             VkSemaphore,
+                             VkFence) {
     close(fence);
     return VK_SUCCESS;
 }
@@ -953,10 +948,10 @@
 void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
 }
 
-void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
+void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
 }
 
-void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
+void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
 }
 
 void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth) {
@@ -1046,10 +1041,10 @@
 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 CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
 }
 
-void CmdPipelineBarrier(VkCommandBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+void CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
 }
 
 void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
deleted file mode 100644
index 1018afa..0000000
--- a/vulkan/nulldrv/null_driver.h
+++ /dev/null
@@ -1,174 +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 NULLDRV_NULL_DRIVER_H
-#define NULLDRV_NULL_DRIVER_H 1
-
-#define VK_PROTOTYPES
-#include <vulkan/vulkan.h>
-#include <vulkan/vk_android_native_buffer.h>
-
-namespace null_driver {
-
-PFN_vkVoidFunction LookupInstanceProcAddr(const char* name);
-PFN_vkVoidFunction LookupDeviceProcAddr(const char* name);
-
-// clang-format off
-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);
-
-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
-
-#endif  // NULLDRV_NULL_DRIVER_H
diff --git a/vulkan/nulldrv/null_driver.tmpl b/vulkan/nulldrv/null_driver.tmpl
new file mode 100644
index 0000000..7762011
--- /dev/null
+++ b/vulkan/nulldrv/null_driver.tmpl
@@ -0,0 +1,222 @@
+{{/*
+ * 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.
+ */}}
+
+{{Include "../api/templates/vulkan_common.tmpl"}}
+{{Global "clang-format" (Strings "clang-format" "-style=file")}}
+{{Macro "DefineGlobals" $}}
+{{$ | Macro "null_driver_gen.h"   | Format (Global "clang-format") | Write "null_driver_gen.h"  }}
+{{$ | Macro "null_driver_gen.cpp" | Format (Global "clang-format") | Write "null_driver_gen.cpp"}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  null_driver_gen.h
+-------------------------------------------------------------------------------
+*/}}
+{{define "null_driver_gen.h"}}
+/*
+•* 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.
+•*/
+¶
+// This file is generated. Do not edit manually!
+// To regenerate: $ apic template ../api/vulkan.api null_driver.tmpl
+// Requires apic from https://android.googlesource.com/platform/tools/gpu/.
+¶
+#ifndef NULLDRV_NULL_DRIVER_H
+#define NULLDRV_NULL_DRIVER_H 1
+¶
+#define VK_PROTOTYPES
+#include <vulkan/vk_android_native_buffer.h>
+#include <vulkan/vulkan.h>
+¶
+namespace null_driver {«
+¶
+PFN_vkVoidFunction GetGlobalProcAddr(const char* name);
+PFN_vkVoidFunction GetInstanceProcAddr(const char* name);
+¶
+// clang-format off
+  {{range $f := AllCommands $}}
+    {{if (Macro "IsDriverFunction" $f)}}
+VKAPI_ATTR {{Node "Type" $f.Return}} {{Macro "BaseName" $f}}({{Macro "Parameters" $f}});
+    {{end}}
+  {{end}}
+VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
+VKAPI_ATTR VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
+VKAPI_ATTR VkResult QueueSignalReleaseImageANDROID(VkQueue queue, VkImage image, int* pNativeFenceFd);
+// clang-format on
+¶
+»}  // namespace null_driver
+¶
+#endif  // NULLDRV_NULL_DRIVER_H
+¶{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  null_driver_gen.cpp
+-------------------------------------------------------------------------------
+*/}}
+{{define "null_driver_gen.cpp"}}
+/*
+•* 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.
+•*/
+¶
+// This file is generated. Do not edit manually!
+// To regenerate: $ apic template ../api/vulkan.api null_driver.tmpl
+// Requires apic from https://android.googlesource.com/platform/tools/gpu/.
+¶
+#include "null_driver_gen.h"
+#include <algorithm>
+¶
+using namespace null_driver;
+¶
+namespace {
+¶
+struct NameProc {
+    const char* name;
+    PFN_vkVoidFunction proc;
+};
+¶
+PFN_vkVoidFunction Lookup(const char* name,
+                          const NameProc* begin,
+                          const NameProc* end) {
+    const auto& entry = std::lower_bound(
+        begin, end, name,
+        [](const NameProc& e, const char* n) { return strcmp(e.name, n) < 0; });
+    if (entry == end || strcmp(entry->name, name) != 0)
+        return nullptr;
+    return entry->proc;
+}
+¶
+template <size_t N>
+PFN_vkVoidFunction Lookup(const char* name, const NameProc (&procs)[N]) {
+    return Lookup(name, procs, procs + N);
+}
+¶
+const NameProc kGlobalProcs[] = {«
+  // clang-format off
+  {{range $f := SortBy (AllCommands $) "FunctionName"}}
+    {{if and (Macro "IsDriverFunction" $f) (eq (Macro "Vtbl" $f) "Global")}}
+      {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§
+        static_cast<{{Macro "FunctionPtrName" $f}}>(§
+          {{Macro "BaseName" $f}}))},
+    {{end}}
+  {{end}}
+  // clang-format on
+»};
+¶
+const NameProc kInstanceProcs[] = {«
+  // clang-format off
+  {{range $f := SortBy (AllCommands $) "FunctionName"}}
+    {{if (Macro "IsDriverFunction" $f)}}
+      {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§
+        static_cast<{{Macro "FunctionPtrName" $f}}>(§
+          {{Macro "BaseName" $f}}))},
+    {{end}}
+  {{end}}
+  // clang-format on
+»};
+¶
+} // namespace
+¶
+namespace null_driver {
+¶
+PFN_vkVoidFunction GetGlobalProcAddr(const char* name) {
+    return Lookup(name, kGlobalProcs);
+}
+¶
+PFN_vkVoidFunction GetInstanceProcAddr(const char* name) {«
+    PFN_vkVoidFunction pfn;
+    if ((pfn = Lookup(name, kInstanceProcs)))
+        return pfn;
+    if (strcmp(name, "vkGetSwapchainGrallocUsageANDROID") == 0)
+        return reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetSwapchainGrallocUsageANDROID>(GetSwapchainGrallocUsageANDROID));
+    if (strcmp(name, "vkAcquireImageANDROID") == 0)
+        return reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAcquireImageANDROID>(AcquireImageANDROID));
+    if (strcmp(name, "vkQueueSignalReleaseImageANDROID") == 0)
+        return reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkQueueSignalReleaseImageANDROID>(QueueSignalReleaseImageANDROID));
+    return nullptr;
+»}
+¶
+} // namespace null_driver
+¶
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  Emits a function name without the "vk" prefix.
+-------------------------------------------------------------------------------
+*/}}
+{{define "BaseName"}}
+  {{AssertType $ "Function"}}
+  {{TrimPrefix "vk" $.Name}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emits 'true' if the API function is implemented by the driver.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsDriverFunction"}}
+  {{AssertType $ "Function"}}
+
+  {{if not (GetAnnotation $ "pfn")}}
+    {{$ext := GetAnnotation $ "extension"}}
+    {{if $ext}}
+      {{Macro "IsDriverExtension" $ext}}
+    {{else}}
+      true
+    {{end}}
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Reports whether an extension is implemented by the driver.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsDriverExtension"}}
+  {{$ext := index $.Arguments 0}}
+  {{if eq $ext "VK_ANDROID_native_buffer"}}true
+  {{end}}
+{{end}}
diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
index c732131..a96c2c4 100644
--- a/vulkan/nulldrv/null_driver_gen.cpp
+++ b/vulkan/nulldrv/null_driver_gen.cpp
@@ -1,71 +1,60 @@
 /*
-* 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.
-*/
+ * 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.
+ */
 
 // This file is generated. Do not edit manually!
-// To regenerate: $ apic template ../api/vulkan.api null_driver_gen.cpp.tmpl
+// To regenerate: $ apic template ../api/vulkan.api null_driver.tmpl
 // Requires apic from https://android.googlesource.com/platform/tools/gpu/.
 
+#include "null_driver_gen.h"
 #include <algorithm>
-#include "null_driver.h"
 
 using namespace null_driver;
 
 namespace {
 
-struct NameProcEntry {
+struct NameProc {
     const char* name;
     PFN_vkVoidFunction proc;
 };
 
-template <size_t 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) {
-                                      return strcmp(e.name, n) < 0;
-                                  });
-    if (entry != (table + N) && strcmp(entry->name, name) == 0)
-        return entry->proc;
-    return nullptr;
+PFN_vkVoidFunction Lookup(const char* name,
+                          const NameProc* begin,
+                          const NameProc* end) {
+    const auto& entry = std::lower_bound(
+        begin, end, name,
+        [](const NameProc& e, const char* n) { return strcmp(e.name, n) < 0; });
+    if (entry == end || strcmp(entry->name, name) != 0)
+        return nullptr;
+    return entry->proc;
 }
 
-// The reinterpret_cast<..>(static_cast<..>(..)) business is there to ensure
-// that the function declaration in null_driver.h matches the function pointer
-// type in vulkan.h. If we just used reinterpret_cast<>, the compiler wouldn't
-// tell us if there's a mistake in null_driver.h. A better solution would be to
-// generate the declarations in null_driver.h.
-const NameProcEntry kInstanceProcTbl[] = {
+template <size_t N>
+PFN_vkVoidFunction Lookup(const char* name, const NameProc (&procs)[N]) {
+    return Lookup(name, procs, procs + N);
+}
+
+const NameProc kGlobalProcs[] = {
     // clang-format off
-    {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDevice>(CreateDevice))},
-    {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyInstance>(DestroyInstance))},
-    {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceExtensionProperties>(EnumerateDeviceExtensionProperties))},
-    {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceLayerProperties>(EnumerateDeviceLayerProperties))},
-    {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumeratePhysicalDevices>(EnumeratePhysicalDevices))},
-    {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetInstanceProcAddr>(GetInstanceProcAddr))},
-    {"vkGetPhysicalDeviceFeatures", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFeatures>(GetPhysicalDeviceFeatures))},
-    {"vkGetPhysicalDeviceFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFormatProperties>(GetPhysicalDeviceFormatProperties))},
-    {"vkGetPhysicalDeviceImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(GetPhysicalDeviceImageFormatProperties))},
-    {"vkGetPhysicalDeviceMemoryProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(GetPhysicalDeviceMemoryProperties))},
-    {"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceProperties>(GetPhysicalDeviceProperties))},
-    {"vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(GetPhysicalDeviceQueueFamilyProperties))},
-    {"vkGetPhysicalDeviceSparseImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(GetPhysicalDeviceSparseImageFormatProperties))},
+    {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateInstance>(CreateInstance))},
+    {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceExtensionProperties>(EnumerateInstanceExtensionProperties))},
+    {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceLayerProperties>(EnumerateInstanceLayerProperties))},
     // clang-format on
 };
 
-const NameProcEntry kDeviceProcTbl[] = {
+const NameProc kInstanceProcs[] = {
     // clang-format off
     {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateCommandBuffers>(AllocateCommandBuffers))},
     {"vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateDescriptorSets>(AllocateDescriptorSets))},
@@ -123,12 +112,14 @@
     {"vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateComputePipelines>(CreateComputePipelines))},
     {"vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDescriptorPool>(CreateDescriptorPool))},
     {"vkCreateDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDescriptorSetLayout>(CreateDescriptorSetLayout))},
+    {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDevice>(CreateDevice))},
     {"vkCreateEvent", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateEvent>(CreateEvent))},
     {"vkCreateFence", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateFence>(CreateFence))},
     {"vkCreateFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateFramebuffer>(CreateFramebuffer))},
     {"vkCreateGraphicsPipelines", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateGraphicsPipelines>(CreateGraphicsPipelines))},
     {"vkCreateImage", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateImage>(CreateImage))},
     {"vkCreateImageView", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateImageView>(CreateImageView))},
+    {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateInstance>(CreateInstance))},
     {"vkCreatePipelineCache", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreatePipelineCache>(CreatePipelineCache))},
     {"vkCreatePipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreatePipelineLayout>(CreatePipelineLayout))},
     {"vkCreateQueryPool", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateQueryPool>(CreateQueryPool))},
@@ -147,6 +138,7 @@
     {"vkDestroyFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyFramebuffer>(DestroyFramebuffer))},
     {"vkDestroyImage", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyImage>(DestroyImage))},
     {"vkDestroyImageView", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyImageView>(DestroyImageView))},
+    {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyInstance>(DestroyInstance))},
     {"vkDestroyPipeline", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyPipeline>(DestroyPipeline))},
     {"vkDestroyPipelineCache", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyPipelineCache>(DestroyPipelineCache))},
     {"vkDestroyPipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyPipelineLayout>(DestroyPipelineLayout))},
@@ -157,6 +149,11 @@
     {"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))},
+    {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceExtensionProperties>(EnumerateDeviceExtensionProperties))},
+    {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceLayerProperties>(EnumerateDeviceLayerProperties))},
+    {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceExtensionProperties>(EnumerateInstanceExtensionProperties))},
+    {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceLayerProperties>(EnumerateInstanceLayerProperties))},
+    {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumeratePhysicalDevices>(EnumeratePhysicalDevices))},
     {"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))},
@@ -170,6 +167,14 @@
     {"vkGetImageMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetImageMemoryRequirements>(GetImageMemoryRequirements))},
     {"vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetImageSparseMemoryRequirements>(GetImageSparseMemoryRequirements))},
     {"vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetImageSubresourceLayout>(GetImageSubresourceLayout))},
+    {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetInstanceProcAddr>(GetInstanceProcAddr))},
+    {"vkGetPhysicalDeviceFeatures", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFeatures>(GetPhysicalDeviceFeatures))},
+    {"vkGetPhysicalDeviceFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFormatProperties>(GetPhysicalDeviceFormatProperties))},
+    {"vkGetPhysicalDeviceImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(GetPhysicalDeviceImageFormatProperties))},
+    {"vkGetPhysicalDeviceMemoryProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(GetPhysicalDeviceMemoryProperties))},
+    {"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceProperties>(GetPhysicalDeviceProperties))},
+    {"vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(GetPhysicalDeviceQueueFamilyProperties))},
+    {"vkGetPhysicalDeviceSparseImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(GetPhysicalDeviceSparseImageFormatProperties))},
     {"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPipelineCacheData>(GetPipelineCacheData))},
     {"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetQueryPoolResults>(GetQueryPoolResults))},
     {"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetRenderAreaGranularity>(GetRenderAreaGranularity))},
@@ -195,12 +200,26 @@
 
 namespace null_driver {
 
-PFN_vkVoidFunction LookupInstanceProcAddr(const char* name) {
-    return LookupProcAddr(kInstanceProcTbl, name);
+PFN_vkVoidFunction GetGlobalProcAddr(const char* name) {
+    return Lookup(name, kGlobalProcs);
 }
 
-PFN_vkVoidFunction LookupDeviceProcAddr(const char* name) {
-    return LookupProcAddr(kDeviceProcTbl, name);
+PFN_vkVoidFunction GetInstanceProcAddr(const char* name) {
+    PFN_vkVoidFunction pfn;
+    if ((pfn = Lookup(name, kInstanceProcs)))
+        return pfn;
+    if (strcmp(name, "vkGetSwapchainGrallocUsageANDROID") == 0)
+        return reinterpret_cast<PFN_vkVoidFunction>(
+            static_cast<PFN_vkGetSwapchainGrallocUsageANDROID>(
+                GetSwapchainGrallocUsageANDROID));
+    if (strcmp(name, "vkAcquireImageANDROID") == 0)
+        return reinterpret_cast<PFN_vkVoidFunction>(
+            static_cast<PFN_vkAcquireImageANDROID>(AcquireImageANDROID));
+    if (strcmp(name, "vkQueueSignalReleaseImageANDROID") == 0)
+        return reinterpret_cast<PFN_vkVoidFunction>(
+            static_cast<PFN_vkQueueSignalReleaseImageANDROID>(
+                QueueSignalReleaseImageANDROID));
+    return nullptr;
 }
 
 }  // namespace null_driver
diff --git a/vulkan/nulldrv/null_driver_gen.cpp.tmpl b/vulkan/nulldrv/null_driver_gen.cpp.tmpl
deleted file mode 100644
index d749c6e..0000000
--- a/vulkan/nulldrv/null_driver_gen.cpp.tmpl
+++ /dev/null
@@ -1,122 +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.
- */}}
-
-{{Include "../api/templates/vulkan_common.tmpl"}}
-{{Global "clang-format" (Strings "clang-format" "-style=file")}}
-{{Macro "DefineGlobals" $}}
-{{$ | Macro "null_driver_gen.cpp" | Format (Global "clang-format") | Write "null_driver_gen.cpp"}}
-
-
-{{/*
--------------------------------------------------------------------------------
-  Entry point
--------------------------------------------------------------------------------
-*/}}
-{{define "null_driver_gen.cpp"}}
-/*
- * 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.
- */
-¶
-// This file is generated. Do not edit manually!
-// To regenerate: $ apic template ../api/vulkan.api null_driver_gen.cpp.tmpl
-// Requires apic from https://android.googlesource.com/platform/tools/gpu/.
-¶
-#include <algorithm>
-#include "null_driver.h"
-¶
-using namespace null_driver;
-¶
-namespace {
-¶
-struct NameProcEntry {
-    const char* name;
-    PFN_vkVoidFunction proc;
-};
-¶
-template <size_t 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) { return strcmp(e.name, n) < 0; });
-    if (entry != (table + N) && strcmp(entry->name, name) == 0)
-        return entry->proc;
-    return nullptr;
-}
-¶
-// The reinterpret_cast<..>(static_cast<..>(..)) business is there to ensure
-// that the function declaration in null_driver.h matches the function pointer
-// type in vulkan.h. If we just used reinterpret_cast<>, the compiler wouldn't
-// tell us if there's a mistake in null_driver.h. A better solution would be to
-// generate the declarations in null_driver.h.
-const NameProcEntry kInstanceProcTbl[] = {«
-  // clang-format off
-  {{range $f := SortBy (AllCommands $) "FunctionName"}}
-    {{if not (GetAnnotation $f "extension")}}
-      {{if eq (Macro "Vtbl" $f) "Instance"}}
-        {"{{Macro "FunctionName" $f}}", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vk{{Macro "FunctionNameNoPrefix" $f}}>({{Macro "FunctionNameNoPrefix" $f}}))},
-      {{end}}
-    {{end}}
-  {{end}}
-  // clang-format on
-»};
-¶
-const NameProcEntry kDeviceProcTbl[] = {«
-  // clang-format off
-  {{range $f := SortBy (AllCommands $) "FunctionName"}}
-    {{if not (GetAnnotation $f "extension")}}
-      {{if eq (Macro "Vtbl" $f) "Device"}}
-        {"{{Macro "FunctionName" $f}}", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vk{{Macro "FunctionNameNoPrefix" $f}}>({{Macro "FunctionNameNoPrefix" $f}}))},
-      {{end}}
-    {{end}}
-  {{end}}
-  // clang-format on
-»};
-¶
-} // namespace
-¶
-namespace null_driver {
-¶
-PFN_vkVoidFunction LookupInstanceProcAddr(const char* name) {
-    return LookupProcAddr(kInstanceProcTbl, name);
-}
-¶
-PFN_vkVoidFunction LookupDeviceProcAddr(const char* name) {
-    return LookupProcAddr(kDeviceProcTbl, name);
-}
-¶
-} // namespace null_driver
-¶
-{{end}}
-
-
-{{/*
--------------------------------------------------------------------------------
-  Emits the name of a function without the "vk" prefix.
--------------------------------------------------------------------------------
-*/}}
-{{define "FunctionNameNoPrefix"}}{{AssertType $ "Function"}}{{TrimPrefix "vk" $.Name}}{{end}}
diff --git a/vulkan/nulldrv/null_driver_gen.h b/vulkan/nulldrv/null_driver_gen.h
new file mode 100644
index 0000000..99c1017
--- /dev/null
+++ b/vulkan/nulldrv/null_driver_gen.h
@@ -0,0 +1,178 @@
+/*
+ * 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.
+ */
+
+// This file is generated. Do not edit manually!
+// To regenerate: $ apic template ../api/vulkan.api null_driver.tmpl
+// Requires apic from https://android.googlesource.com/platform/tools/gpu/.
+
+#ifndef NULLDRV_NULL_DRIVER_H
+#define NULLDRV_NULL_DRIVER_H 1
+
+#define VK_PROTOTYPES
+#include <vulkan/vk_android_native_buffer.h>
+#include <vulkan/vulkan.h>
+
+namespace null_driver {
+
+PFN_vkVoidFunction GetGlobalProcAddr(const char* name);
+PFN_vkVoidFunction GetInstanceProcAddr(const char* name);
+
+// clang-format off
+VKAPI_ATTR VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
+VKAPI_ATTR void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
+VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
+VKAPI_ATTR void GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+VKAPI_ATTR void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+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 VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
+VKAPI_ATTR void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+VKAPI_ATTR VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+VKAPI_ATTR VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* 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* pSubmits, VkFence fence);
+VKAPI_ATTR VkResult QueueWaitIdle(VkQueue queue);
+VKAPI_ATTR VkResult DeviceWaitIdle(VkDevice device);
+VKAPI_ATTR VkResult AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
+VKAPI_ATTR void FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
+VKAPI_ATTR void UnmapMemory(VkDevice device, VkDeviceMemory memory);
+VKAPI_ATTR VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
+VKAPI_ATTR VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
+VKAPI_ATTR void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+VKAPI_ATTR void GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+VKAPI_ATTR VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+VKAPI_ATTR void GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+VKAPI_ATTR VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+VKAPI_ATTR void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, 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* pAllocator, VkFence* pFence);
+VKAPI_ATTR void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
+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* pAllocator, VkSemaphore* pSemaphore);
+VKAPI_ATTR void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
+VKAPI_ATTR void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
+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* pAllocator, VkQueryPool* pQueryPool);
+VKAPI_ATTR void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+VKAPI_ATTR VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
+VKAPI_ATTR void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
+VKAPI_ATTR void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
+VKAPI_ATTR void DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+VKAPI_ATTR VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
+VKAPI_ATTR void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
+VKAPI_ATTR void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
+VKAPI_ATTR void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+VKAPI_ATTR VkResult MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+VKAPI_ATTR VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+VKAPI_ATTR VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+VKAPI_ATTR void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
+VKAPI_ATTR void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
+VKAPI_ATTR void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
+VKAPI_ATTR void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
+VKAPI_ATTR void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+VKAPI_ATTR VkResult AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
+VKAPI_ATTR VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
+VKAPI_ATTR void UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+VKAPI_ATTR VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
+VKAPI_ATTR void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+VKAPI_ATTR void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+VKAPI_ATTR VkResult CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
+VKAPI_ATTR void DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
+VKAPI_ATTR VkResult AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
+VKAPI_ATTR void FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
+VKAPI_ATTR VkResult BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+VKAPI_ATTR VkResult EndCommandBuffer(VkCommandBuffer commandBuffer);
+VKAPI_ATTR VkResult ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
+VKAPI_ATTR void CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+VKAPI_ATTR void CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
+VKAPI_ATTR void CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
+VKAPI_ATTR void CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth);
+VKAPI_ATTR void CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
+VKAPI_ATTR void CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]);
+VKAPI_ATTR void CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
+VKAPI_ATTR void CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
+VKAPI_ATTR void CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
+VKAPI_ATTR void CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
+VKAPI_ATTR void CmdBindDescriptorSets(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 CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+VKAPI_ATTR void CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+VKAPI_ATTR void CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+VKAPI_ATTR void CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+VKAPI_ATTR void CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+VKAPI_ATTR void CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+VKAPI_ATTR void CmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
+VKAPI_ATTR void CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
+VKAPI_ATTR void CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+VKAPI_ATTR void CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+VKAPI_ATTR void CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+VKAPI_ATTR void CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+VKAPI_ATTR void CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+VKAPI_ATTR void CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData);
+VKAPI_ATTR void CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
+VKAPI_ATTR void CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+VKAPI_ATTR void CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+VKAPI_ATTR void CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+VKAPI_ATTR void CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+VKAPI_ATTR void CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+VKAPI_ATTR void CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+VKAPI_ATTR void CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+VKAPI_ATTR void CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+VKAPI_ATTR void CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
+VKAPI_ATTR void CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
+VKAPI_ATTR void CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
+VKAPI_ATTR void CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
+VKAPI_ATTR void CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+VKAPI_ATTR void CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
+VKAPI_ATTR void CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
+VKAPI_ATTR void CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
+VKAPI_ATTR void CmdEndRenderPass(VkCommandBuffer commandBuffer);
+VKAPI_ATTR void CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
+VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
+VKAPI_ATTR VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
+VKAPI_ATTR VkResult QueueSignalReleaseImageANDROID(VkQueue queue, VkImage image, int* pNativeFenceFd);
+// clang-format on
+
+}  // namespace null_driver
+
+#endif  // NULLDRV_NULL_DRIVER_H
diff --git a/vulkan/patches/README b/vulkan/patches/README
index a458d94..d424dd8 100644
--- a/vulkan/patches/README
+++ b/vulkan/patches/README
@@ -12,12 +12,6 @@
 
 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
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0001-vulkan-Update-from-version-0.172.2-to-0.174.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0001-vulkan-Update-from-version-0.172.2-to-0.174.0.patch
deleted file mode 100644
index b4845c3..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0001-vulkan-Update-from-version-0.172.2-to-0.174.0.patch
+++ /dev/null
@@ -1,505 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0002-vulkan-Update-from-version-0.174.0-to-0.177.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0002-vulkan-Update-from-version-0.174.0-to-0.177.0.patch
deleted file mode 100644
index 1dba313..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0002-vulkan-Update-from-version-0.174.0-to-0.177.0.patch
+++ /dev/null
@@ -1,206 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0003-vulkan-Update-from-version-0.177.0-to-0.179.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0003-vulkan-Update-from-version-0.177.0-to-0.179.0.patch
deleted file mode 100644
index b447e96..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0003-vulkan-Update-from-version-0.177.0-to-0.179.0.patch
+++ /dev/null
@@ -1,1092 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0004-vulkan-Update-from-version-0.179.0-to-0.180.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0004-vulkan-Update-from-version-0.179.0-to-0.180.0.patch
deleted file mode 100644
index f1bb009..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0004-vulkan-Update-from-version-0.179.0-to-0.180.0.patch
+++ /dev/null
@@ -1,186 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0005-vulkan-Update-from-version-0.180.0-to-0.181.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0005-vulkan-Update-from-version-0.180.0-to-0.181.0.patch
deleted file mode 100644
index b2c5693..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0005-vulkan-Update-from-version-0.180.0-to-0.181.0.patch
+++ /dev/null
@@ -1,614 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0006-vulkan-Update-from-version-0.181.0-to-0.183.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0006-vulkan-Update-from-version-0.181.0-to-0.183.0.patch
deleted file mode 100644
index 7d7da37..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0006-vulkan-Update-from-version-0.181.0-to-0.183.0.patch
+++ /dev/null
@@ -1,960 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0007-vulkan-Implement-VkSurfaceKHR-and-use-vulkanext.h.patch b/vulkan/patches/frameworks_native-sdk_0.10/0007-vulkan-Implement-VkSurfaceKHR-and-use-vulkanext.h.patch
deleted file mode 100644
index b6bc011..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0007-vulkan-Implement-VkSurfaceKHR-and-use-vulkanext.h.patch
+++ /dev/null
@@ -1,2418 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0008-vulkan-Update-from-version-0.183.0-to-0.184.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0008-vulkan-Update-from-version-0.183.0-to-0.184.0.patch
deleted file mode 100644
index dc01c44..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0008-vulkan-Update-from-version-0.183.0-to-0.184.0.patch
+++ /dev/null
@@ -1,533 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0009-vulkan.api-Distinguish-Vk-Flags-from-Vk-FlagBits.patch b/vulkan/patches/frameworks_native-sdk_0.10/0009-vulkan.api-Distinguish-Vk-Flags-from-Vk-FlagBits.patch
deleted file mode 100644
index 6a8b56a..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0009-vulkan.api-Distinguish-Vk-Flags-from-Vk-FlagBits.patch
+++ /dev/null
@@ -1,735 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0010-vulkan-Update-from-version-0.184.0-to-0.185.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0010-vulkan-Update-from-version-0.184.0-to-0.185.0.patch
deleted file mode 100644
index 037bb33..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0010-vulkan-Update-from-version-0.184.0-to-0.185.0.patch
+++ /dev/null
@@ -1,324 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0011-vulkan-Update-from-version-0.185.0-to-0.186.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0011-vulkan-Update-from-version-0.185.0-to-0.186.0.patch
deleted file mode 100644
index 940c4eb..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0011-vulkan-Update-from-version-0.185.0-to-0.186.0.patch
+++ /dev/null
@@ -1,384 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0012-vulkan-Update-from-version-0.186.0-to-0.188.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0012-vulkan-Update-from-version-0.186.0-to-0.188.0.patch
deleted file mode 100644
index 9f3e477..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0012-vulkan-Update-from-version-0.186.0-to-0.188.0.patch
+++ /dev/null
@@ -1,3907 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0013-vulkan-Update-from-version-0.188.0-to-0.189.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0013-vulkan-Update-from-version-0.188.0-to-0.189.0.patch
deleted file mode 100644
index 67d99fd..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0013-vulkan-Update-from-version-0.188.0-to-0.189.0.patch
+++ /dev/null
@@ -1,245 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0014-vulkan-Update-from-version-0.189.0-to-0.190.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0014-vulkan-Update-from-version-0.189.0-to-0.190.0.patch
deleted file mode 100644
index d23327b..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0014-vulkan-Update-from-version-0.189.0-to-0.190.0.patch
+++ /dev/null
@@ -1,2052 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0015-vulkan-Update-from-version-0.190.0-to-0.192.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0015-vulkan-Update-from-version-0.190.0-to-0.192.0.patch
deleted file mode 100644
index 63065c0..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0015-vulkan-Update-from-version-0.190.0-to-0.192.0.patch
+++ /dev/null
@@ -1,246 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0016-vulkan-Update-from-version-0.192.0-to-0.193.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0016-vulkan-Update-from-version-0.192.0-to-0.193.0.patch
deleted file mode 100644
index 5496741..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0016-vulkan-Update-from-version-0.192.0-to-0.193.0.patch
+++ /dev/null
@@ -1,1095 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0017-vulkan-Update-from-version-0.193.0-to-0.194.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0017-vulkan-Update-from-version-0.193.0-to-0.194.0.patch
deleted file mode 100644
index fffd40c..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0017-vulkan-Update-from-version-0.193.0-to-0.194.0.patch
+++ /dev/null
@@ -1,613 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0018-vulkan-Update-from-version-0.194.0-to-0.196.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0018-vulkan-Update-from-version-0.194.0-to-0.196.0.patch
deleted file mode 100644
index eab1cd7..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0018-vulkan-Update-from-version-0.194.0-to-0.196.0.patch
+++ /dev/null
@@ -1,6993 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0019-vulkan-Update-from-version-0.196.0-to-0.197.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0019-vulkan-Update-from-version-0.196.0-to-0.197.0.patch
deleted file mode 100644
index 5269766..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0019-vulkan-Update-from-version-0.196.0-to-0.197.0.patch
+++ /dev/null
@@ -1,220 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0020-vulkan-Update-from-version-0.197.0-to-0.198.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0020-vulkan-Update-from-version-0.197.0-to-0.198.0.patch
deleted file mode 100644
index 09e7224..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0020-vulkan-Update-from-version-0.197.0-to-0.198.0.patch
+++ /dev/null
@@ -1,1422 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0021-vulkan-Update-from-version-0.198.0-to-0.200.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0021-vulkan-Update-from-version-0.198.0-to-0.200.0.patch
deleted file mode 100644
index e416675..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0021-vulkan-Update-from-version-0.198.0-to-0.200.0.patch
+++ /dev/null
@@ -1,3349 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0022-vulkan-Update-from-version-0.200.0-to-0.202.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0022-vulkan-Update-from-version-0.200.0-to-0.202.0.patch
deleted file mode 100644
index e73e345..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0022-vulkan-Update-from-version-0.200.0-to-0.202.0.patch
+++ /dev/null
@@ -1,497 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0023-vulkan-Update-from-version-0.202.0-to-0.203.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0023-vulkan-Update-from-version-0.202.0-to-0.203.0.patch
deleted file mode 100644
index d05a728..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0023-vulkan-Update-from-version-0.202.0-to-0.203.0.patch
+++ /dev/null
@@ -1,300 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0024-vulkan-Update-from-version-0.203.0-to-0.204.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0024-vulkan-Update-from-version-0.203.0-to-0.204.0.patch
deleted file mode 100644
index 541cc49..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0024-vulkan-Update-from-version-0.203.0-to-0.204.0.patch
+++ /dev/null
@@ -1,3365 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0025-vulkan-Update-from-version-0.204.0-to-0.205.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0025-vulkan-Update-from-version-0.204.0-to-0.205.0.patch
deleted file mode 100644
index 6174a64..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0025-vulkan-Update-from-version-0.204.0-to-0.205.0.patch
+++ /dev/null
@@ -1,581 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0026-vulkan-Update-from-version-0.205.0-to-0.206.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0026-vulkan-Update-from-version-0.205.0-to-0.206.0.patch
deleted file mode 100644
index f79ee4e..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0026-vulkan-Update-from-version-0.205.0-to-0.206.0.patch
+++ /dev/null
@@ -1,292 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0027-vulkan-Update-from-version-0.206.0-to-0.209.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0027-vulkan-Update-from-version-0.206.0-to-0.209.0.patch
deleted file mode 100644
index fe01c4f..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0027-vulkan-Update-from-version-0.206.0-to-0.209.0.patch
+++ /dev/null
@@ -1,1441 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0028-vulkan-Update-from-version-0.209.0-to-0.210.0.patch b/vulkan/patches/frameworks_native-sdk_0.10/0028-vulkan-Update-from-version-0.209.0-to-0.210.0.patch
deleted file mode 100644
index b42fc0b..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0028-vulkan-Update-from-version-0.209.0-to-0.210.0.patch
+++ /dev/null
@@ -1,291 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0029-vulkan-Assign-enums-to-the-correct-extension.patch b/vulkan/patches/frameworks_native-sdk_0.10/0029-vulkan-Assign-enums-to-the-correct-extension.patch
deleted file mode 100644
index 9113680..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0029-vulkan-Assign-enums-to-the-correct-extension.patch
+++ /dev/null
@@ -1,56 +0,0 @@
-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
-
diff --git a/vulkan/patches/frameworks_native-sdk_0.10/0030-vulkan-Update-from-version-0.210.0-to-0.210.1.patch b/vulkan/patches/frameworks_native-sdk_0.10/0030-vulkan-Update-from-version-0.210.0-to-0.210.1.patch
deleted file mode 100644
index a5c11b5..0000000
--- a/vulkan/patches/frameworks_native-sdk_0.10/0030-vulkan-Update-from-version-0.210.0-to-0.210.1.patch
+++ /dev/null
@@ -1,212 +0,0 @@
-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
-
diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
index c63dca4..221c7be 100644
--- a/vulkan/tools/vkinfo.cpp
+++ b/vulkan/tools/vkinfo.cpp
@@ -15,8 +15,8 @@
  */
 
 #include <inttypes.h>
-#include <sstream>
 #include <stdlib.h>
+#include <sstream>
 #include <vector>
 
 #define VK_PROTOTYPES
@@ -27,6 +27,23 @@
 
 namespace {
 
+struct GpuInfo {
+    VkPhysicalDeviceProperties properties;
+    VkPhysicalDeviceMemoryProperties memory;
+    std::vector<VkQueueFamilyProperties> queue_families;
+    std::vector<VkExtensionProperties> extensions;
+    std::vector<VkLayerProperties> layers;
+    std::vector<std::vector<VkExtensionProperties>> layer_extensions;
+};
+struct VulkanInfo {
+    std::vector<VkExtensionProperties> extensions;
+    std::vector<VkLayerProperties> layers;
+    std::vector<std::vector<VkExtensionProperties>> layer_extensions;
+    std::vector<GpuInfo> gpus;
+};
+
+// ----------------------------------------------------------------------------
+
 [[noreturn]] void die(const char* proc, VkResult result) {
     const char* result_str;
     switch (result) {
@@ -52,6 +69,131 @@
     exit(1);
 }
 
+void EnumerateInstanceExtensions(
+    const char* layer_name,
+    std::vector<VkExtensionProperties>* extensions) {
+    VkResult result;
+    uint32_t count;
+    result =
+        vkEnumerateInstanceExtensionProperties(layer_name, &count, nullptr);
+    if (result != VK_SUCCESS)
+        die("vkEnumerateInstanceExtensionProperties (count)", result);
+    do {
+        extensions->resize(count);
+        result = vkEnumerateInstanceExtensionProperties(layer_name, &count,
+                                                        extensions->data());
+    } while (result == VK_INCOMPLETE);
+    if (result != VK_SUCCESS)
+        die("vkEnumerateInstanceExtensionProperties (data)", result);
+}
+
+void EnumerateDeviceExtensions(VkPhysicalDevice gpu,
+                               const char* layer_name,
+                               std::vector<VkExtensionProperties>* extensions) {
+    VkResult result;
+    uint32_t count;
+    result =
+        vkEnumerateDeviceExtensionProperties(gpu, layer_name, &count, nullptr);
+    if (result != VK_SUCCESS)
+        die("vkEnumerateDeviceExtensionProperties (count)", result);
+    do {
+        extensions->resize(count);
+        result = vkEnumerateDeviceExtensionProperties(gpu, layer_name, &count,
+                                                      extensions->data());
+    } while (result == VK_INCOMPLETE);
+    if (result != VK_SUCCESS)
+        die("vkEnumerateDeviceExtensionProperties (data)", result);
+}
+
+void GatherInfo(VulkanInfo* info) {
+    VkResult result;
+    uint32_t count;
+
+    result = vkEnumerateInstanceLayerProperties(&count, nullptr);
+    if (result != VK_SUCCESS)
+        die("vkEnumerateInstanceLayerProperties (count)", result);
+    do {
+        info->layers.resize(count);
+        result =
+            vkEnumerateInstanceLayerProperties(&count, info->layers.data());
+    } while (result == VK_INCOMPLETE);
+    if (result != VK_SUCCESS)
+        die("vkEnumerateInstanceLayerProperties (data)", result);
+    info->layer_extensions.resize(info->layers.size());
+
+    EnumerateInstanceExtensions(nullptr, &info->extensions);
+    for (size_t i = 0; i < info->layers.size(); i++) {
+        EnumerateInstanceExtensions(info->layers[i].layerName,
+                                    &info->layer_extensions[i]);
+    }
+
+    VkInstance instance;
+    const VkInstanceCreateInfo create_info = {
+        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+    };
+    result = vkCreateInstance(&create_info, nullptr, &instance);
+    if (result != VK_SUCCESS)
+        die("vkCreateInstance", result);
+
+    uint32_t num_gpus;
+    result = vkEnumeratePhysicalDevices(instance, &num_gpus, nullptr);
+    if (result != VK_SUCCESS)
+        die("vkEnumeratePhysicalDevices (count)", result);
+    std::vector<VkPhysicalDevice> gpus(num_gpus, VK_NULL_HANDLE);
+    do {
+        gpus.resize(num_gpus, VK_NULL_HANDLE);
+        result = vkEnumeratePhysicalDevices(instance, &num_gpus, gpus.data());
+    } while (result == VK_INCOMPLETE);
+    if (result != VK_SUCCESS)
+        die("vkEnumeratePhysicalDevices (data)", result);
+
+    info->gpus.resize(num_gpus);
+    for (size_t gpu_idx = 0; gpu_idx < gpus.size(); gpu_idx++) {
+        VkPhysicalDevice gpu = gpus[gpu_idx];
+        GpuInfo& gpu_info = info->gpus.at(gpu_idx);
+
+        vkGetPhysicalDeviceProperties(gpu, &gpu_info.properties);
+        vkGetPhysicalDeviceMemoryProperties(gpu, &gpu_info.memory);
+
+        vkGetPhysicalDeviceQueueFamilyProperties(gpu, &count, nullptr);
+        gpu_info.queue_families.resize(count);
+        vkGetPhysicalDeviceQueueFamilyProperties(
+            gpu, &count, gpu_info.queue_families.data());
+
+        result = vkEnumerateDeviceLayerProperties(gpu, &count, nullptr);
+        if (result != VK_SUCCESS)
+            die("vkEnumerateDeviceLayerProperties (count)", result);
+        do {
+            gpu_info.layers.resize(count);
+            result = vkEnumerateDeviceLayerProperties(gpu, &count,
+                                                      gpu_info.layers.data());
+        } while (result == VK_INCOMPLETE);
+        if (result != VK_SUCCESS)
+            die("vkEnumerateDeviceLayerProperties (data)", result);
+        gpu_info.layer_extensions.resize(gpu_info.layers.size());
+
+        EnumerateDeviceExtensions(gpu, nullptr, &gpu_info.extensions);
+        for (size_t i = 0; i < gpu_info.layers.size(); i++) {
+            EnumerateDeviceExtensions(gpu, gpu_info.layers[i].layerName,
+                                      &gpu_info.layer_extensions[i]);
+        }
+    }
+
+    vkDestroyInstance(instance, nullptr);
+}
+
+// ----------------------------------------------------------------------------
+
+uint32_t ExtractMajorVersion(uint32_t version) {
+    return (version >> 22) & 0x3FF;
+}
+uint32_t ExtractMinorVersion(uint32_t version) {
+    return (version >> 12) & 0x3FF;
+}
+uint32_t ExtractPatchVersion(uint32_t version) {
+    return (version >> 0) & 0xFFF;
+}
+
 const char* VkPhysicalDeviceTypeStr(VkPhysicalDeviceType type) {
     switch (type) {
         case VK_PHYSICAL_DEVICE_TYPE_OTHER:
@@ -82,57 +224,55 @@
     }
 }
 
-void DumpPhysicalDevice(uint32_t idx, VkPhysicalDevice pdev) {
+void PrintExtensions(const std::vector<VkExtensionProperties>& extensions,
+                     const char* prefix) {
+    for (const auto& e : extensions)
+        printf("%s- %s (v%u)\n", prefix, e.extensionName, e.specVersion);
+}
+
+void PrintGpuInfo(const GpuInfo& info) {
     VkResult result;
     std::ostringstream strbuf;
 
-    VkPhysicalDeviceProperties props;
-    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,
-           (props.apiVersion >> 0) & 0xFFF, props.driverVersion, props.vendorID,
-           props.deviceID);
+    printf("  - \"%s\" (%s) %u.%u.%u/%#x [%04x:%04x]\n",
+           info.properties.deviceName,
+           VkPhysicalDeviceTypeStr(info.properties.deviceType),
+           ExtractMajorVersion(info.properties.apiVersion),
+           ExtractMinorVersion(info.properties.apiVersion),
+           ExtractPatchVersion(info.properties.apiVersion),
+           info.properties.driverVersion, info.properties.vendorID,
+           info.properties.deviceID);
 
-    VkPhysicalDeviceMemoryProperties mem_props;
-    vkGetPhysicalDeviceMemoryProperties(pdev, &mem_props);
-    for (uint32_t heap = 0; heap < mem_props.memoryHeapCount; heap++) {
-        if ((mem_props.memoryHeaps[heap].flags &
+    for (uint32_t heap = 0; heap < info.memory.memoryHeapCount; heap++) {
+        if ((info.memory.memoryHeaps[heap].flags &
              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());
+        printf("    Heap %u: 0x%" PRIx64 " %s\n", heap,
+               info.memory.memoryHeaps[heap].size, strbuf.str().c_str());
         strbuf.str(std::string());
 
-        for (uint32_t type = 0; type < mem_props.memoryTypeCount; type++) {
-            if (mem_props.memoryTypes[type].heapIndex != heap)
+        for (uint32_t type = 0; type < info.memory.memoryTypeCount; type++) {
+            if (info.memory.memoryTypes[type].heapIndex != heap)
                 continue;
             VkMemoryPropertyFlags flags =
-                mem_props.memoryTypes[type].propertyFlags;
+                info.memory.memoryTypes[type].propertyFlags;
             if ((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
-                strbuf << "DEVICE_LOCAL";
+                strbuf << " DEVICE_LOCAL";
             if ((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
-                strbuf << "HOST_VISIBLE";
+                strbuf << " HOST_VISIBLE";
             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());
+            printf("      Type %u:%s\n", type, strbuf.str().c_str());
             strbuf.str(std::string());
         }
     }
 
-    uint32_t num_queue_families;
-    vkGetPhysicalDeviceQueueFamilyProperties(pdev, &num_queue_families,
-                                             nullptr);
-    std::vector<VkQueueFamilyProperties> queue_family_properties(
-        num_queue_families);
-    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];
+    for (uint32_t family = 0; family < info.queue_families.size(); family++) {
+        const VkQueueFamilyProperties& qprops = info.queue_families[family];
         const char* sep = "";
         int bit, queue_flags = static_cast<int>(qprops.queueFlags);
         while ((bit = __builtin_ffs(queue_flags)) != 0) {
@@ -141,54 +281,68 @@
             queue_flags &= ~flag;
             sep = "+";
         }
-        printf("     Queue Family %u: %2ux %s timestamps:%ub\n", family,
+        printf("    Queue Family %u: %2ux %s timestamps:%ub\n", family,
                qprops.queueCount, strbuf.str().c_str(),
                qprops.timestampValidBits);
         strbuf.str(std::string());
+
+        if (!info.extensions.empty()) {
+            printf("    Extensions [%u]:\n", info.extensions.size());
+            PrintExtensions(info.extensions, "    ");
+        }
+        if (!info.layers.empty()) {
+            printf("    Layers [%u]:\n", info.layers.size());
+            for (size_t i = 0; i < info.layers.size(); i++) {
+                const auto& layer = info.layers[i];
+                printf("    - %s %u.%u.%u/%u \"%s\"\n", layer.layerName,
+                       ExtractMajorVersion(layer.specVersion),
+                       ExtractMinorVersion(layer.specVersion),
+                       ExtractPatchVersion(layer.specVersion),
+                       layer.implementationVersion, layer.description);
+                if (!info.layer_extensions[i].empty()) {
+                    printf("       Extensions [%zu]:\n",
+                           info.layer_extensions.size());
+                    PrintExtensions(info.layer_extensions[i], "       ");
+                }
+            }
+        }
     }
 }
 
+void PrintInfo(const VulkanInfo& info) {
+    std::ostringstream strbuf;
+
+    printf("Instance Extensions [%u]:\n", info.extensions.size());
+    PrintExtensions(info.extensions, "  ");
+    if (!info.layers.empty()) {
+        printf("Instance Layers [%u]:\n", info.layers.size());
+        for (size_t i = 0; i < info.layers.size(); i++) {
+            const auto& layer = info.layers[i];
+            printf("  - %s %u.%u.%u/%u \"%s\"\n", layer.layerName,
+                   ExtractMajorVersion(layer.specVersion),
+                   ExtractMinorVersion(layer.specVersion),
+                   ExtractPatchVersion(layer.specVersion),
+                   layer.implementationVersion, layer.description);
+            if (!info.layer_extensions[i].empty()) {
+                printf("     Extensions [%zu]:\n",
+                       info.layer_extensions.size());
+                PrintExtensions(info.layer_extensions[i], "       ");
+            }
+        }
+    }
+
+    printf("PhysicalDevices [%zu]:\n", info.gpus.size());
+    for (const auto& gpu : info.gpus)
+        PrintGpuInfo(gpu);
+}
+
 }  // namespace
 
+// ----------------------------------------------------------------------------
+
 int main(int /*argc*/, char const* /*argv*/ []) {
-    VkResult result;
-
-    VkInstance instance;
-    const VkInstanceCreateInfo create_info = {
-        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
-        .pNext = nullptr,
-        .pApplicationInfo = nullptr,
-        .enabledLayerNameCount = 0,
-        .ppEnabledLayerNames = nullptr,
-        .enabledExtensionNameCount = 0,
-        .ppEnabledExtensionNames = nullptr,
-    };
-    result = vkCreateInstance(&create_info, nullptr, &instance);
-    if (result != VK_SUCCESS)
-        die("vkCreateInstance", result);
-
-    uint32_t num_physical_devices;
-    result =
-        vkEnumeratePhysicalDevices(instance, &num_physical_devices, nullptr);
-    if (result != VK_SUCCESS)
-        die("vkEnumeratePhysicalDevices (count)", result);
-    std::vector<VkPhysicalDevice> physical_devices(num_physical_devices,
-                                                   VK_NULL_HANDLE);
-    result = vkEnumeratePhysicalDevices(instance, &num_physical_devices,
-                                        physical_devices.data());
-    if (result != VK_SUCCESS)
-        die("vkEnumeratePhysicalDevices (data)", result);
-    if (num_physical_devices != physical_devices.size()) {
-        fprintf(stderr,
-                "number of physical devices decreased from %zu to %u!\n",
-                physical_devices.size(), num_physical_devices);
-        physical_devices.resize(num_physical_devices);
-    }
-    printf("PhysicalDevices:\n");
-    for (uint32_t i = 0; i < physical_devices.size(); i++)
-        DumpPhysicalDevice(i, physical_devices[i]);
-
-    vkDestroyInstance(instance, nullptr);
-
+    VulkanInfo info;
+    GatherInfo(&info);
+    PrintInfo(info);
     return 0;
 }