diff --git a/include/vulkan.h b/include/vulkan.h
index 03fcb6f..ae4fe6d 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -100,12 +100,12 @@
 #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 @@
     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 @@
 } 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 @@
 } 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_POLYGON_MODE_FILL = 0,
+    VK_POLYGON_MODE_LINE = 1,
+    VK_POLYGON_MODE_POINT = 2,
+    VK_FILL_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
+    VK_FILL_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
+    VK_FILL_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
     VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF
-} VkFillMode;
+} VkPolygonMode;
 
 typedef enum {
     VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
@@ -581,30 +581,30 @@
 } 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_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_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
+    VK_BLEND_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
+    VK_BLEND_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
     VK_BLEND_MAX_ENUM = 0x7FFFFFFF
-} VkBlend;
+} VkBlendFactor;
 
 typedef enum {
     VK_BLEND_OP_ADD = 0,
@@ -743,13 +743,13 @@
 } 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 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,11 +935,11 @@
 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;
+    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 VkChannelFlags;
 typedef VkFlags VkPipelineDynamicStateCreateFlags;
 typedef VkFlags VkPipelineLayoutCreateFlags;
@@ -1041,7 +1041,7 @@
 typedef VkFlags VkStencilFaceFlags;
 
 typedef enum {
-    VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001,
+    VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
 } VkQueryControlFlagBits;
 typedef VkFlags VkQueryControlFlags;
 
@@ -1119,7 +1119,7 @@
     VkBool32                                    multiDrawIndirect;
     VkBool32                                    depthClamp;
     VkBool32                                    depthBiasClamp;
-    VkBool32                                    fillModeNonSolid;
+    VkBool32                                    polygonModeNonSolid;
     VkBool32                                    depthBounds;
     VkBool32                                    wideLines;
     VkBool32                                    largePoints;
@@ -1129,7 +1129,7 @@
     VkBool32                                    textureCompressionETC2;
     VkBool32                                    textureCompressionASTC_LDR;
     VkBool32                                    textureCompressionBC;
-    VkBool32                                    occlusionQueryNonConservative;
+    VkBool32                                    occlusionQueryPrecise;
     VkBool32                                    pipelineStatisticsQuery;
     VkBool32                                    vertexPipelineStoresAndAtomics;
     VkBool32                                    fragmentStoresAndAtomics;
@@ -1280,8 +1280,8 @@
     float                                       pointSizeGranularity;
     float                                       lineWidthGranularity;
     VkBool32                                    strictLines;
-    VkDeviceSize                                recommendedBufferCopyOffsetAlignment;
-    VkDeviceSize                                recommendedBufferCopyRowPitchAlignment;
+    VkDeviceSize                                optimalBufferCopyOffsetAlignment;
+    VkDeviceSize                                optimalBufferCopyRowPitchAlignment;
 } VkPhysicalDeviceLimits;
 
 typedef struct {
@@ -1298,8 +1298,8 @@
     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;
@@ -1351,15 +1351,15 @@
 } 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 {
@@ -1544,11 +1544,11 @@
 } 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;
@@ -1565,7 +1565,7 @@
     VkImage                                     image;
     VkImageViewType                             viewType;
     VkFormat                                    format;
-    VkChannelMapping                            channels;
+    VkComponentMapping                            channels;
     VkImageSubresourceRange                     subresourceRange;
 } VkImageViewCreateInfo;
 
@@ -1618,7 +1618,7 @@
 typedef struct {
     uint32_t                                    binding;
     uint32_t                                    stride;
-    VkVertexInputStepRate                       stepRate;
+    VkVertexInputRate                       inputRate;
 } VkVertexInputBindingDescription;
 
 typedef struct {
@@ -1654,8 +1654,8 @@
 } VkPipelineTessellationStateCreateInfo;
 
 typedef struct {
-    float                                       originX;
-    float                                       originY;
+    float                                       x;
+    float                                       y;
     float                                       width;
     float                                       height;
     float                                       minDepth;
@@ -1693,7 +1693,7 @@
     VkPipelineRasterizationStateCreateFlags     flags;
     VkBool32                                    depthClampEnable;
     VkBool32                                    rasterizerDiscardEnable;
-    VkFillMode                                  fillMode;
+    VkPolygonMode                                  polygonMode;
     VkCullModeFlags                             cullMode;
     VkFrontFace                                 frontFace;
     VkBool32                                    depthBiasEnable;
@@ -1716,13 +1716,13 @@
 } 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 {
@@ -1742,13 +1742,13 @@
 
 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;
+    VkChannelFlags                              colorWriteMask;
 } VkPipelineColorBlendAttachmentState;
 
 typedef struct {
@@ -1856,15 +1856,15 @@
 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 {
@@ -2011,21 +2011,21 @@
     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;
@@ -2034,7 +2034,7 @@
     VkDeviceSize                                bufferOffset;
     uint32_t                                    bufferRowLength;
     uint32_t                                    bufferImageHeight;
-    VkImageSubresourceCopy                      imageSubresource;
+    VkImageSubresourceLayers                      imageSubresource;
     VkOffset3D                                  imageOffset;
     VkExtent3D                                  imageExtent;
 } VkBufferImageCopy;
@@ -2068,9 +2068,9 @@
 } VkClearRect;
 
 typedef struct {
-    VkImageSubresourceCopy                      srcSubresource;
+    VkImageSubresourceLayers                      srcSubresource;
     VkOffset3D                                  srcOffset;
-    VkImageSubresourceCopy                      dstSubresource;
+    VkImageSubresourceLayers                      dstSubresource;
     VkOffset3D                                  dstOffset;
     VkExtent3D                                  extent;
 } VkImageResolve;
@@ -2241,9 +2241,9 @@
 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);
@@ -2274,8 +2274,8 @@
 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_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);
 
@@ -2830,17 +2830,17 @@
 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,
@@ -3064,11 +3064,11 @@
 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);
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index d170830..46f0ba6 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1133,16 +1133,16 @@
             skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
                     "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocateDescriptorSets() call", (uint64_t) pSetLayouts[i]);
         } else {
-            uint32_t typeIndex = 0, typeCount = 0;
+            uint32_t typeIndex = 0, poolSizeCount = 0;
             for (j=0; j<pLayout->createInfo.bindingCount; ++j) {
                 typeIndex = static_cast<uint32_t>(pLayout->createInfo.pBindings[j].descriptorType);
-                typeCount = pLayout->createInfo.pBindings[j].arraySize;
-                if (typeCount > pPoolNode->availableDescriptorTypeCount[typeIndex]) {
+                poolSizeCount = pLayout->createInfo.pBindings[j].arraySize;
+                if (poolSizeCount > pPoolNode->availableDescriptorTypeCount[typeIndex]) {
                     skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pLayout->layout, 0, DRAWSTATE_DESCRIPTOR_POOL_EMPTY, "DS",
                         "Unable to allocate %u descriptors of type %s from pool %#" PRIxLEAST64 ". This pool only has %u descriptors of this type remaining.",
-                            typeCount, string_VkDescriptorType(pLayout->createInfo.pBindings[j].descriptorType), (uint64_t) pPoolNode->pool, pPoolNode->availableDescriptorTypeCount[typeIndex]);
+                            poolSizeCount, string_VkDescriptorType(pLayout->createInfo.pBindings[j].descriptorType), (uint64_t) pPoolNode->pool, pPoolNode->availableDescriptorTypeCount[typeIndex]);
                 } else { // Decrement available descriptors of this type
-                    pPoolNode->availableDescriptorTypeCount[typeIndex] -= typeCount;
+                    pPoolNode->availableDescriptorTypeCount[typeIndex] -= poolSizeCount;
                 }
             }
         }
@@ -1357,7 +1357,7 @@
 static void set_cb_pso_status(GLOBAL_CB_NODE* pCB, const PIPELINE_NODE* pPipe)
 {
     for (uint32_t i = 0; i < pPipe->cbStateCI.attachmentCount; i++) {
-        if (0 != pPipe->pAttachments[i].channelWriteMask) {
+        if (0 != pPipe->pAttachments[i].colorWriteMask) {
             pCB->status |= CBSTATUS_COLOR_BLEND_WRITE_ENABLE;
         }
     }
@@ -2216,11 +2216,11 @@
         for (uint32_t i=0; i<count; ++i) {
             SET_NODE* pSet = dev_data->setMap[pDescriptorSets[i]]; // getSetNode() without locking
             LAYOUT_NODE* pLayout = pSet->pLayout;
-            uint32_t typeIndex = 0, typeCount = 0;
+            uint32_t typeIndex = 0, poolSizeCount = 0;
             for (uint32_t j=0; j<pLayout->createInfo.bindingCount; ++j) {
                 typeIndex = static_cast<uint32_t>(pLayout->createInfo.pBindings[j].descriptorType);
-                typeCount = pLayout->createInfo.pBindings[j].arraySize;
-                pPoolNode->availableDescriptorTypeCount[typeIndex] += typeCount;
+                poolSizeCount = pLayout->createInfo.pBindings[j].arraySize;
+                pPoolNode->availableDescriptorTypeCount[typeIndex] += poolSizeCount;
             }
         }
     }
@@ -2516,7 +2516,7 @@
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(
     VkCommandBuffer                         commandBuffer,
     VkStencilFaceFlags                  faceMask,
-    uint32_t                            stencilCompareMask)
+    uint32_t                            compareMask)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
@@ -2526,10 +2526,10 @@
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_SETSTENCILREADMASKSTATE);
             if (faceMask & VK_STENCIL_FACE_FRONT_BIT) {
-                pCB->front.stencilCompareMask = stencilCompareMask;
+                pCB->front.compareMask = compareMask;
             }
             if (faceMask & VK_STENCIL_FACE_BACK_BIT) {
-                pCB->back.stencilCompareMask = stencilCompareMask;
+                pCB->back.compareMask = compareMask;
             }
             /* TODO: Do we need to track front and back separately? */
             /* TODO: We aren't capturing the faceMask, do we need to? */
@@ -2539,13 +2539,13 @@
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
+        dev_data->device_dispatch_table->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(
     VkCommandBuffer                         commandBuffer,
     VkStencilFaceFlags                  faceMask,
-    uint32_t                            stencilWriteMask)
+    uint32_t                            writeMask)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
@@ -2555,10 +2555,10 @@
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_SETSTENCILWRITEMASKSTATE);
             if (faceMask & VK_STENCIL_FACE_FRONT_BIT) {
-                pCB->front.stencilWriteMask = stencilWriteMask;
+                pCB->front.writeMask = writeMask;
             }
             if (faceMask & VK_STENCIL_FACE_BACK_BIT) {
-                pCB->back.stencilWriteMask = stencilWriteMask;
+                pCB->back.writeMask = writeMask;
             }
             pCB->status |= CBSTATUS_STENCIL_WRITE_MASK_SET;
         } else {
@@ -2566,13 +2566,13 @@
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
+        dev_data->device_dispatch_table->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(
     VkCommandBuffer                         commandBuffer,
     VkStencilFaceFlags                  faceMask,
-    uint32_t                            stencilReference)
+    uint32_t                            reference)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
@@ -2582,10 +2582,10 @@
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_SETSTENCILREFERENCESTATE);
             if (faceMask & VK_STENCIL_FACE_FRONT_BIT) {
-                pCB->front.stencilReference = stencilReference;
+                pCB->front.reference = reference;
             }
             if (faceMask & VK_STENCIL_FACE_BACK_BIT) {
-                pCB->back.stencilReference = stencilReference;
+                pCB->back.reference = reference;
             }
             pCB->status |= CBSTATUS_STENCIL_REFERENCE_SET;
         } else {
@@ -2593,7 +2593,7 @@
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
+        dev_data->device_dispatch_table->CmdSetStencilReference(commandBuffer, faceMask, reference);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
@@ -3536,7 +3536,7 @@
     }
     my_data->renderPassMap.clear();
 }
-VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkRenderPassContents contents)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
@@ -3561,7 +3561,7 @@
         dev_data->device_dispatch_table->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkRenderPassContents contents)
+VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
diff --git a/layers/draw_state.h b/layers/draw_state.h
index a5833fd..3aa9494 100755
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -179,16 +179,16 @@
     pool(pool), createInfo(*pCreateInfo), maxSets(pCreateInfo->maxSets), pSets(NULL),
     maxDescriptorTypeCount(VK_DESCRIPTOR_TYPE_END_RANGE), availableDescriptorTypeCount(VK_DESCRIPTOR_TYPE_END_RANGE)
     {
-        if (createInfo.typeCount) { // Shadow type struct from ptr into local struct
-            size_t typeCountSize = createInfo.typeCount * sizeof(VkDescriptorTypeCount);
-            createInfo.pTypeCounts = new VkDescriptorTypeCount[typeCountSize];
-            memcpy((void*)createInfo.pTypeCounts, pCreateInfo->pTypeCounts, typeCountSize);
+        if (createInfo.poolSizeCount) { // Shadow type struct from ptr into local struct
+            size_t poolSizeCountSize = createInfo.poolSizeCount * sizeof(VkDescriptorPoolSize);
+            createInfo.pPoolSizes = new VkDescriptorPoolSize[poolSizeCountSize];
+            memcpy((void*)createInfo.pPoolSizes, pCreateInfo->pPoolSizes, poolSizeCountSize);
             // Now set max counts for each descriptor type based on count of that type times maxSets
             int32_t i=0;
-            for (i=0; i<createInfo.typeCount; ++i) {
-                uint32_t typeIndex = static_cast<uint32_t>(createInfo.pTypeCounts[i].type);
-                uint32_t typeCount = createInfo.pTypeCounts[i].descriptorCount;
-                maxDescriptorTypeCount[typeIndex] += typeCount;
+            for (i=0; i<createInfo.poolSizeCount; ++i) {
+                uint32_t typeIndex = static_cast<uint32_t>(createInfo.pPoolSizes[i].type);
+                uint32_t poolSizeCount = createInfo.pPoolSizes[i].descriptorCount;
+                maxDescriptorTypeCount[typeIndex] += poolSizeCount;
             }
             for (i=0; i<maxDescriptorTypeCount.size(); ++i) {
                 maxDescriptorTypeCount[i] *= createInfo.maxSets;
@@ -196,12 +196,12 @@
                 availableDescriptorTypeCount[i] = maxDescriptorTypeCount[i];
             }
         } else {
-            createInfo.pTypeCounts = NULL; // Make sure this is NULL so we don't try to clean it up
+            createInfo.pPoolSizes = NULL; // Make sure this is NULL so we don't try to clean it up
         }
     }
     ~_POOL_NODE() {
-        if (createInfo.pTypeCounts) {
-            delete[] createInfo.pTypeCounts;
+        if (createInfo.pPoolSizes) {
+            delete[] createInfo.pPoolSizes;
         }
         // TODO : pSets are currently freed in deletePools function which uses freeShadowUpdateTree function
         //  need to migrate that struct to smart ptrs for auto-cleanup
@@ -296,9 +296,9 @@
 } CBStatusFlagBits;
 
 typedef struct stencil_data {
-    uint32_t                     stencilCompareMask;
-    uint32_t                     stencilWriteMask;
-    uint32_t                     stencilReference;
+    uint32_t                     compareMask;
+    uint32_t                     writeMask;
+    uint32_t                     reference;
 } CBStencilData;
 
 // Cmd Buffer Wrapper Struct
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 3744bd5..f4f62c9 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1713,7 +1713,7 @@
 // TODO : For any vkCmdBind* calls that include an object which has mem bound to it,
 //    need to account for that mem now having binding to given commandBuffer
 VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(
-    VkCommandBuffer         commandBuffer,
+    VkCommandBuffer     commandBuffer,
     VkPipelineBindPoint pipelineBindPoint,
     VkPipeline          pipeline)
 {
@@ -1738,7 +1738,7 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(
-    VkCommandBuffer                         commandBuffer,
+    VkCommandBuffer                     commandBuffer,
     uint32_t                            viewportCount,
     const VkViewport*                   pViewports)
 {
@@ -1757,7 +1757,7 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(
-    VkCommandBuffer                         commandBuffer,
+    VkCommandBuffer                     commandBuffer,
     uint32_t                            scissorCount,
     const VkRect2D*                     pScissors)
 {
@@ -1792,7 +1792,7 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBias(
-    VkCommandBuffer                         commandBuffer,
+    VkCommandBuffer                     commandBuffer,
     float                               depthBiasConstantFactor,
     float                               depthBiasClamp,
     float                               depthBiasSlopeFactor)
@@ -1812,7 +1812,7 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(
-     VkCommandBuffer                            commandBuffer,
+     VkCommandBuffer                        commandBuffer,
      const float                            blendConstants[4])
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
@@ -1830,7 +1830,7 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBounds(
-    VkCommandBuffer                         commandBuffer,
+    VkCommandBuffer                     commandBuffer,
     float                               minDepthBounds,
     float                               maxDepthBounds)
 {
@@ -1849,9 +1849,9 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(
-    VkCommandBuffer                         commandBuffer,
+    VkCommandBuffer                     commandBuffer,
     VkStencilFaceFlags                  faceMask,
-    uint32_t                            stencilCompareMask)
+    uint32_t                            compareMask)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
@@ -1863,14 +1863,14 @@
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
+        my_data->device_dispatch_table->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(
-    VkCommandBuffer                         commandBuffer,
+    VkCommandBuffer                     commandBuffer,
     VkStencilFaceFlags                  faceMask,
-    uint32_t                            stencilWriteMask)
+    uint32_t                            writeMask)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
@@ -1882,14 +1882,14 @@
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
+        my_data->device_dispatch_table->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(
-    VkCommandBuffer                         commandBuffer,
+    VkCommandBuffer                     commandBuffer,
     VkStencilFaceFlags                  faceMask,
-    uint32_t                            stencilReference)
+    uint32_t                            reference)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
@@ -1901,12 +1901,12 @@
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
+        my_data->device_dispatch_table->CmdSetStencilReference(commandBuffer, faceMask, reference);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
-    VkCommandBuffer            commandBuffer,
+    VkCommandBuffer        commandBuffer,
     VkPipelineBindPoint    pipelineBindPoint,
     VkPipelineLayout       layout,
     uint32_t               firstSet,
@@ -1922,7 +1922,7 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
-    VkCommandBuffer         commandBuffer,
+    VkCommandBuffer     commandBuffer,
     uint32_t            startBinding,
     uint32_t            bindingCount,
     const VkBuffer     *pBuffers,
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 736128d..f166d91 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -448,7 +448,7 @@
 bool ValidateEnumerator(VkQueueFlagBits const& enumerator)
 {
     VkQueueFlagBits allFlags = (VkQueueFlagBits)(
-        VK_QUEUE_DMA_BIT |
+        VK_QUEUE_TRANSFER_BIT |
         VK_QUEUE_COMPUTE_BIT |
         VK_QUEUE_SPARSE_BINDING_BIT |
         VK_QUEUE_GRAPHICS_BIT);
@@ -469,9 +469,9 @@
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_QUEUE_DMA_BIT)
+    if(enumerator & VK_QUEUE_TRANSFER_BIT)
     {
-        strings.push_back("VK_QUEUE_DMA_BIT");
+        strings.push_back("VK_QUEUE_TRANSFER_BIT");
     }
     if(enumerator & VK_QUEUE_COMPUTE_BIT)
     {
@@ -1031,12 +1031,12 @@
 }
 
 static
-bool ValidateEnumerator(VkChannelFlagBits const& enumerator)
+bool ValidateEnumerator(VkColorComponentFlagBits const& enumerator)
 {
-    VkChannelFlagBits allFlags = (VkChannelFlagBits)(VK_CHANNEL_A_BIT |
-        VK_CHANNEL_B_BIT |
-        VK_CHANNEL_G_BIT |
-        VK_CHANNEL_R_BIT);
+    VkColorComponentFlagBits allFlags = (VkColorComponentFlagBits)(VK_COLOR_COMPONENT_A_BIT |
+        VK_COLOR_COMPONENT_B_BIT |
+        VK_COLOR_COMPONENT_G_BIT |
+        VK_COLOR_COMPONENT_R_BIT);
     if(enumerator & (~allFlags))
     {
         return false;
@@ -1046,7 +1046,7 @@
 }
 
 static
-std::string EnumeratorString(VkChannelFlagBits const& enumerator)
+std::string EnumeratorString(VkColorComponentFlagBits const& enumerator)
 {
     if(!ValidateEnumerator(enumerator))
     {
@@ -1054,21 +1054,21 @@
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_CHANNEL_A_BIT)
+    if(enumerator & VK_COLOR_COMPONENT_A_BIT)
     {
-        strings.push_back("VK_CHANNEL_A_BIT");
+        strings.push_back("VK_COLOR_COMPONENT_A_BIT");
     }
-    if(enumerator & VK_CHANNEL_B_BIT)
+    if(enumerator & VK_COLOR_COMPONENT_B_BIT)
     {
-        strings.push_back("VK_CHANNEL_B_BIT");
+        strings.push_back("VK_COLOR_COMPONENT_B_BIT");
     }
-    if(enumerator & VK_CHANNEL_G_BIT)
+    if(enumerator & VK_COLOR_COMPONENT_G_BIT)
     {
-        strings.push_back("VK_CHANNEL_G_BIT");
+        strings.push_back("VK_COLOR_COMPONENT_G_BIT");
     }
-    if(enumerator & VK_CHANNEL_R_BIT)
+    if(enumerator & VK_COLOR_COMPONENT_R_BIT)
     {
-        strings.push_back("VK_CHANNEL_R_BIT");
+        strings.push_back("VK_COLOR_COMPONENT_R_BIT");
     }
 
     std::string enumeratorString;
@@ -1698,7 +1698,7 @@
 static
 bool ValidateEnumerator(VkQueryControlFlagBits const& enumerator)
 {
-    VkQueryControlFlagBits allFlags = (VkQueryControlFlagBits)(VK_QUERY_CONTROL_CONSERVATIVE_BIT);
+    VkQueryControlFlagBits allFlags = (VkQueryControlFlagBits)(VK_QUERY_CONTROL_PRECISE_BIT);
     if(enumerator & (~allFlags))
     {
         return false;
@@ -1716,9 +1716,9 @@
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_QUERY_CONTROL_CONSERVATIVE_BIT)
+    if(enumerator & VK_QUERY_CONTROL_PRECISE_BIT)
     {
-        strings.push_back("VK_QUERY_CONTROL_CONSERVATIVE_BIT");
+        strings.push_back("VK_QUERY_CONTROL_PRECISE_BIT");
     }
 
     std::string enumeratorString;
@@ -3394,32 +3394,32 @@
         "vkCreateImageView parameter, VkFormat pCreateInfo->format, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfo->channels.r < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
-        pCreateInfo->channels.r > VK_CHANNEL_SWIZZLE_END_RANGE)
+    if(pCreateInfo->channels.r < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
+        pCreateInfo->channels.r > VK_COMPONENT_SWIZZLE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.r, is an unrecognized enumerator");
+        "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->channels.r, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfo->channels.g < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
-        pCreateInfo->channels.g > VK_CHANNEL_SWIZZLE_END_RANGE)
+    if(pCreateInfo->channels.g < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
+        pCreateInfo->channels.g > VK_COMPONENT_SWIZZLE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.g, is an unrecognized enumerator");
+        "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->channels.g, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfo->channels.b < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
-        pCreateInfo->channels.b > VK_CHANNEL_SWIZZLE_END_RANGE)
+    if(pCreateInfo->channels.b < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
+        pCreateInfo->channels.b > VK_COMPONENT_SWIZZLE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.b, is an unrecognized enumerator");
+        "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->channels.b, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfo->channels.a < VK_CHANNEL_SWIZZLE_BEGIN_RANGE ||
-        pCreateInfo->channels.a > VK_CHANNEL_SWIZZLE_END_RANGE)
+    if(pCreateInfo->channels.a < VK_COMPONENT_SWIZZLE_BEGIN_RANGE ||
+        pCreateInfo->channels.a > VK_COMPONENT_SWIZZLE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateImageView parameter, VkChannelSwizzle pCreateInfo->channels.a, is an unrecognized enumerator");
+        "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->channels.a, is an unrecognized enumerator");
         return false;
     }
     }
@@ -3747,11 +3747,11 @@
     }
     if(pCreateInfos->pVertexInputState->pVertexBindingDescriptions != nullptr)
     {
-    if(pCreateInfos->pVertexInputState->pVertexBindingDescriptions->stepRate < VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE ||
-        pCreateInfos->pVertexInputState->pVertexBindingDescriptions->stepRate > VK_VERTEX_INPUT_STEP_RATE_END_RANGE)
+    if(pCreateInfos->pVertexInputState->pVertexBindingDescriptions->inputRate < VK_VERTEX_INPUT_RATE_BEGIN_RANGE ||
+        pCreateInfos->pVertexInputState->pVertexBindingDescriptions->inputRate > VK_VERTEX_INPUT_RATE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkVertexInputStepRate pCreateInfos->pVertexInputState->pVertexBindingDescriptions->stepRate, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkVertexInputRate pCreateInfos->pVertexInputState->pVertexBindingDescriptions->inputRate, is an unrecognized enumerator");
         return false;
     }
     }
@@ -3802,17 +3802,17 @@
     }
     if(pCreateInfos->pRasterizationState != nullptr)
     {
-    if(pCreateInfos->pRasterizationState->sType != VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO)
+    if(pCreateInfos->pRasterizationState->sType != VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pRasterizationState->sType, is an invalid enumerator");
         return false;
     }
-    if(pCreateInfos->pRasterizationState->fillMode < VK_FILL_MODE_BEGIN_RANGE ||
-        pCreateInfos->pRasterizationState->fillMode > VK_FILL_MODE_END_RANGE)
+    if(pCreateInfos->pRasterizationState->polygonMode < VK_FILL_MODE_BEGIN_RANGE ||
+        pCreateInfos->pRasterizationState->polygonMode > VK_FILL_MODE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkFillMode pCreateInfos->pRasterizationState->fillMode, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkPolygonMode pCreateInfos->pRasterizationState->polygonMode, is an unrecognized enumerator");
         return false;
     }
     if(pCreateInfos->pRasterizationState->cullMode & ~VK_CULL_MODE_FRONT_AND_BACK)
@@ -3853,60 +3853,60 @@
         "vkCreateGraphicsPipelines parameter, VkCompareOp pCreateInfos->pDepthStencilState->depthCompareOp, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pDepthStencilState->front.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->front.stencilFailOp > VK_STENCIL_OP_END_RANGE)
+    if(pCreateInfos->pDepthStencilState->front.failOp < VK_STENCIL_OP_BEGIN_RANGE ||
+        pCreateInfos->pDepthStencilState->front.failOp > VK_STENCIL_OP_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.stencilFailOp, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.failOp, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pDepthStencilState->front.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->front.stencilPassOp > VK_STENCIL_OP_END_RANGE)
+    if(pCreateInfos->pDepthStencilState->front.passOp < VK_STENCIL_OP_BEGIN_RANGE ||
+        pCreateInfos->pDepthStencilState->front.passOp > VK_STENCIL_OP_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.stencilPassOp, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.passOp, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pDepthStencilState->front.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->front.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE)
+    if(pCreateInfos->pDepthStencilState->front.depthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
+        pCreateInfos->pDepthStencilState->front.depthFailOp > VK_STENCIL_OP_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.stencilDepthFailOp, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.depthFailOp, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pDepthStencilState->front.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->front.stencilCompareOp > VK_COMPARE_OP_END_RANGE)
+    if(pCreateInfos->pDepthStencilState->front.compareOp < VK_COMPARE_OP_BEGIN_RANGE ||
+        pCreateInfos->pDepthStencilState->front.compareOp > VK_COMPARE_OP_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkCompareOp pCreateInfos->pDepthStencilState->front.stencilCompareOp, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkCompareOp pCreateInfos->pDepthStencilState->front.compareOp, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pDepthStencilState->back.stencilFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->back.stencilFailOp > VK_STENCIL_OP_END_RANGE)
+    if(pCreateInfos->pDepthStencilState->back.failOp < VK_STENCIL_OP_BEGIN_RANGE ||
+        pCreateInfos->pDepthStencilState->back.failOp > VK_STENCIL_OP_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.stencilFailOp, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.failOp, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pDepthStencilState->back.stencilPassOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->back.stencilPassOp > VK_STENCIL_OP_END_RANGE)
+    if(pCreateInfos->pDepthStencilState->back.passOp < VK_STENCIL_OP_BEGIN_RANGE ||
+        pCreateInfos->pDepthStencilState->back.passOp > VK_STENCIL_OP_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.stencilPassOp, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.passOp, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pDepthStencilState->back.stencilDepthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->back.stencilDepthFailOp > VK_STENCIL_OP_END_RANGE)
+    if(pCreateInfos->pDepthStencilState->back.depthFailOp < VK_STENCIL_OP_BEGIN_RANGE ||
+        pCreateInfos->pDepthStencilState->back.depthFailOp > VK_STENCIL_OP_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.stencilDepthFailOp, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.depthFailOp, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pDepthStencilState->back.stencilCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
-        pCreateInfos->pDepthStencilState->back.stencilCompareOp > VK_COMPARE_OP_END_RANGE)
+    if(pCreateInfos->pDepthStencilState->back.compareOp < VK_COMPARE_OP_BEGIN_RANGE ||
+        pCreateInfos->pDepthStencilState->back.compareOp > VK_COMPARE_OP_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkCompareOp pCreateInfos->pDepthStencilState->back.stencilCompareOp, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkCompareOp pCreateInfos->pDepthStencilState->back.compareOp, is an unrecognized enumerator");
         return false;
     }
     }
@@ -3928,46 +3928,46 @@
     }
     if(pCreateInfos->pColorBlendState->pAttachments != nullptr && pCreateInfos->pColorBlendState->pAttachments->blendEnable == VK_TRUE)
     {
-    if(pCreateInfos->pColorBlendState->pAttachments->srcBlendColor < VK_BLEND_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->srcBlendColor > VK_BLEND_END_RANGE)
+    if(pCreateInfos->pColorBlendState->pAttachments->srcColorBlendFactor < VK_BLEND_BEGIN_RANGE ||
+        pCreateInfos->pColorBlendState->pAttachments->srcColorBlendFactor > VK_BLEND_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->srcBlendColor, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->srcColorBlendFactor, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pColorBlendState->pAttachments->dstBlendColor < VK_BLEND_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->dstBlendColor > VK_BLEND_END_RANGE)
+    if(pCreateInfos->pColorBlendState->pAttachments->dstColorBlendFactor < VK_BLEND_BEGIN_RANGE ||
+        pCreateInfos->pColorBlendState->pAttachments->dstColorBlendFactor > VK_BLEND_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->dstBlendColor, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->dstColorBlendFactor, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pColorBlendState->pAttachments->blendOpColor < VK_BLEND_OP_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->blendOpColor > VK_BLEND_OP_END_RANGE)
+    if(pCreateInfos->pColorBlendState->pAttachments->colorBlendOp < VK_BLEND_OP_BEGIN_RANGE ||
+        pCreateInfos->pColorBlendState->pAttachments->colorBlendOp > VK_BLEND_OP_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlendOp pCreateInfos->pColorBlendState->pAttachments->blendOpColor, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkBlendOp pCreateInfos->pColorBlendState->pAttachments->colorBlendOp, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pColorBlendState->pAttachments->srcBlendAlpha < VK_BLEND_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->srcBlendAlpha > VK_BLEND_END_RANGE)
+    if(pCreateInfos->pColorBlendState->pAttachments->srcAlphaBlendFactor < VK_BLEND_BEGIN_RANGE ||
+        pCreateInfos->pColorBlendState->pAttachments->srcAlphaBlendFactor > VK_BLEND_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->srcBlendAlpha, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->srcAlphaBlendFactor, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pColorBlendState->pAttachments->dstBlendAlpha < VK_BLEND_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->dstBlendAlpha > VK_BLEND_END_RANGE)
+    if(pCreateInfos->pColorBlendState->pAttachments->dstAlphaBlendFactor < VK_BLEND_BEGIN_RANGE ||
+        pCreateInfos->pColorBlendState->pAttachments->dstAlphaBlendFactor > VK_BLEND_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->dstBlendAlpha, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->dstAlphaBlendFactor, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pColorBlendState->pAttachments->blendOpAlpha < VK_BLEND_OP_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->blendOpAlpha > VK_BLEND_OP_END_RANGE)
+    if(pCreateInfos->pColorBlendState->pAttachments->alphaBlendOp < VK_BLEND_OP_BEGIN_RANGE ||
+        pCreateInfos->pColorBlendState->pAttachments->alphaBlendOp > VK_BLEND_OP_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkBlendOp pCreateInfos->pColorBlendState->pAttachments->blendOpAlpha, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkBlendOp pCreateInfos->pColorBlendState->pAttachments->alphaBlendOp, is an unrecognized enumerator");
         return false;
     }
     }
@@ -4339,10 +4339,10 @@
         "vkCreateDescriptorPool parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
         return false;
     }
-    if(pCreateInfo->pTypeCounts != nullptr)
+    if(pCreateInfo->pPoolSizes != nullptr)
     {
-    if(pCreateInfo->pTypeCounts->type < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
-        pCreateInfo->pTypeCounts->type > VK_DESCRIPTOR_TYPE_END_RANGE)
+    if(pCreateInfo->pPoolSizes->type < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
+        pCreateInfo->pPoolSizes->type > VK_DESCRIPTOR_TYPE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCreateDescriptorPool parameter, VkDescriptorType pCreateInfo->pTypeCount->type, is an unrecognized enumerator");
@@ -5114,19 +5114,19 @@
     get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask)
+VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
 {
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask)
+VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
 {
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference)
+VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
 {
-    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, reference);
 }
 
 bool PreCmdBindDescriptorSets(
@@ -6310,14 +6310,14 @@
 
 bool PostCmdBeginRenderPass(
     VkCommandBuffer commandBuffer,
-    VkRenderPassContents contents)
+    VkSubpassContents contents)
 {
 
-    if(contents < VK_RENDER_PASS_CONTENTS_BEGIN_RANGE ||
-        contents > VK_RENDER_PASS_CONTENTS_END_RANGE)
+    if(contents < VK_SUBPASS_CONTENTS_BEGIN_RANGE ||
+        contents > VK_SUBPASS_CONTENTS_END_RANGE)
     {
         log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCmdBeginRenderPass parameter, VkRenderPassContents contents, is an unrecognized enumerator");
+        "vkCmdBeginRenderPass parameter, VkSubpassContents contents, is an unrecognized enumerator");
         return false;
     }
 
@@ -6327,7 +6327,7 @@
 VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(
     VkCommandBuffer commandBuffer,
     const VkRenderPassBeginInfo* pRenderPassBegin,
-    VkRenderPassContents contents)
+    VkSubpassContents contents)
 {
     PreCmdBeginRenderPass(commandBuffer, pRenderPassBegin);
 
@@ -6338,14 +6338,14 @@
 
 bool PostCmdNextSubpass(
     VkCommandBuffer commandBuffer,
-    VkRenderPassContents contents)
+    VkSubpassContents contents)
 {
 
-    if(contents < VK_RENDER_PASS_CONTENTS_BEGIN_RANGE ||
-        contents > VK_RENDER_PASS_CONTENTS_END_RANGE)
+    if(contents < VK_SUBPASS_CONTENTS_BEGIN_RANGE ||
+        contents > VK_SUBPASS_CONTENTS_END_RANGE)
     {
         log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCmdNextSubpass parameter, VkRenderPassContents contents, is an unrecognized enumerator");
+        "vkCmdNextSubpass parameter, VkSubpassContents contents, is an unrecognized enumerator");
         return false;
     }
 
@@ -6354,7 +6354,7 @@
 
 VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(
     VkCommandBuffer commandBuffer,
-    VkRenderPassContents contents)
+    VkSubpassContents contents)
 {
     get_dispatch_table(pc_device_table_map, commandBuffer)->CmdNextSubpass(commandBuffer, contents);
 
diff --git a/layers/vk_validation_layer_details.md b/layers/vk_validation_layer_details.md
index f13c2b0..faadaa0 100644
--- a/layers/vk_validation_layer_details.md
+++ b/layers/vk_validation_layer_details.md
@@ -107,7 +107,7 @@
 Additional work to be done
 
  1. Source2 was creating a VK_FORMAT_R8_SRGB texture (and image view) which was not supported by the underlying implementation (rendersystemtest imageformat test).  Checking that formats are supported by the implementation is something the validation layer could do using the VK_FORMAT_INFO_TYPE_PROPERTIES query.   There are probably a bunch of checks here you could be doing around vkCreateImage formats along with whether image/color/depth attachment views are valid.  I’m not sure how much of this is already there.
- 2.  From AMD: we were using an image view with a swizzle of VK_CHANNEL_FORMAT_A with a BC1_RGB texture, which is not valid because the texture does not have an alpha channel.  In general, should validate that the swizzles do not reference components not in the texture format.
+ 2.  From AMD: we were using an image view with a swizzle of VK_COLOR_COMPONENT_FORMAT_A with a BC1_RGB texture, which is not valid because the texture does not have an alpha channel.  In general, should validate that the swizzles do not reference components not in the texture format.
  3. When querying VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES must provide enough memory for a all the queues on the device (not just 1 when device has multiple queues).
  4. INT & FLOAT bordercolors. Border color int/float selection must match associated texture format.
  5. Flag error on VkBufferCreateInfo if buffer size is 0
diff --git a/loader/loader.h b/loader/loader.h
index 2e64e4b..b93a8e8 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -43,7 +43,7 @@
 #  define LOADER_EXPORT
 #endif
 
-#define MAX_EXTENSION_NAME_SIZE (VK_MAX_EXTENSION_NAME-1)
+#define MAX_EXTENSION_NAME_SIZE (VK_MAX_EXTENSION_NAME_SIZE-1)
 #define MAX_GPUS_PER_ICD 16
 #define MAX_STRING_SIZE 1024
 #define VK_MAJOR(version) (version >> 22)
diff --git a/loader/trampoline.c b/loader/trampoline.c
index fb863f6..13515ad 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -1114,31 +1114,31 @@
     disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask)
+LOADER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
+    disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask)
+LOADER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
+    disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference)
+LOADER_EXPORT void VKAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
+    disp->CmdSetStencilReference(commandBuffer, faceMask, reference);
 }
 
 LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
@@ -1411,7 +1411,7 @@
     disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, values);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents)
+LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
 {
     const VkLayerDispatchTable *disp;
 
@@ -1420,7 +1420,7 @@
     disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
 }
 
-LOADER_EXPORT void VKAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkRenderPassContents contents)
+LOADER_EXPORT void VKAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
 {
     const VkLayerDispatchTable *disp;
 
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index ea5e71f..919488e 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -70,7 +70,7 @@
     bool walk(Action action, Image &img) const;
     bool walk_region(Action action, const VkBufferImageCopy &region, const VkSubresourceLayout &layout, void *data) const;
 
-    std::vector<uint8_t> pattern_hash(const VkImageSubresourceCopy &subres, const VkOffset3D &offset) const;
+    std::vector<uint8_t> pattern_hash(const VkImageSubresourceLayers &subres, const VkOffset3D &offset) const;
 
     static uint32_t hash_salt_;
 
@@ -269,7 +269,7 @@
     return (it == regions_.end());
 }
 
-std::vector<uint8_t> ImageChecker::pattern_hash(const VkImageSubresourceCopy &subres, const VkOffset3D &offset) const
+std::vector<uint8_t> ImageChecker::pattern_hash(const VkImageSubresourceLayers &subres, const VkOffset3D &offset) const
 {
 #define HASH_BYTE(val, b) static_cast<uint8_t>((static_cast<uint32_t>(val) >> (b * 8)) & 0xff)
 #define HASH_BYTES(val) HASH_BYTE(val, 0), HASH_BYTE(val, 1), HASH_BYTE(val, 2), HASH_BYTE(val, 3)
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index de642f6..22b1d1f 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -274,7 +274,7 @@
     //        VkImage                               image;
     //        VkImageViewType                     viewType;
     //        VkFormat                              format;
-    //        VkChannelMapping                     channels;
+    //        VkComponentMapping                     channels;
     //        VkImageSubresourceRange             subresourceRange;
     //        float                                   minLod;
     //    } VkImageViewCreateInfo;
@@ -283,10 +283,10 @@
     viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
     viewInfo.format = fmt;
 
-    viewInfo.channels.r = VK_CHANNEL_SWIZZLE_R;
-    viewInfo.channels.g = VK_CHANNEL_SWIZZLE_G;
-    viewInfo.channels.b = VK_CHANNEL_SWIZZLE_B;
-    viewInfo.channels.a = VK_CHANNEL_SWIZZLE_A;
+    viewInfo.channels.r = VK_COMPONENT_SWIZZLE_R;
+    viewInfo.channels.g = VK_COMPONENT_SWIZZLE_G;
+    viewInfo.channels.b = VK_COMPONENT_SWIZZLE_B;
+    viewInfo.channels.a = VK_COMPONENT_SWIZZLE_A;
 
     viewInfo.subresourceRange.baseArrayLayer = 0;
     viewInfo.subresourceRange.layerCount = 1;
diff --git a/tests/init.cpp b/tests/init.cpp
index 452c58f..cb55b1a 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -436,7 +436,7 @@
 //        VkImage                               image;
 //        VkImageViewType                     viewType;
 //        VkFormat                              format;
-//        VkChannelMapping                     channels;
+//        VkComponentMapping                     channels;
 //        VkImageSubresourceRange             subresourceRange;
 //        float                                   minLod;
 //    } VkImageViewCreateInfo;
@@ -447,10 +447,10 @@
     viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
     viewInfo.format = fmt;
 
-    viewInfo.channels.r = VK_CHANNEL_SWIZZLE_R;
-    viewInfo.channels.g = VK_CHANNEL_SWIZZLE_G;
-    viewInfo.channels.b = VK_CHANNEL_SWIZZLE_B;
-    viewInfo.channels.a = VK_CHANNEL_SWIZZLE_A;
+    viewInfo.channels.r = VK_COMPONENT_SWIZZLE_R;
+    viewInfo.channels.g = VK_COMPONENT_SWIZZLE_G;
+    viewInfo.channels.b = VK_COMPONENT_SWIZZLE_B;
+    viewInfo.channels.a = VK_COMPONENT_SWIZZLE_A;
 
     viewInfo.subresourceRange.baseArrayLayer = 0;
     viewInfo.subresourceRange.layerCount = 1;
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 94ef3db..c36c99c 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -357,10 +357,10 @@
     // Make sure depthWriteEnable is set so that Depth fail test will work correctly
     // Make sure stencilTestEnable is set so that Stencil fail test will work correctly
     VkStencilOpState stencil = {};
-    stencil.stencilFailOp = VK_STENCIL_OP_KEEP;
-    stencil.stencilPassOp = VK_STENCIL_OP_KEEP;
-    stencil.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
-    stencil.stencilCompareOp = VK_COMPARE_OP_NEVER;
+    stencil.failOp = VK_STENCIL_OP_KEEP;
+    stencil.passOp = VK_STENCIL_OP_KEEP;
+    stencil.depthFailOp = VK_STENCIL_OP_KEEP;
+    stencil.compareOp = VK_COMPARE_OP_NEVER;
 
     VkPipelineDepthStencilStateCreateInfo ds_ci = {};
     ds_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
@@ -848,7 +848,7 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -856,8 +856,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -1069,7 +1069,7 @@
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -1077,8 +1077,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -1342,7 +1342,7 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -1350,8 +1350,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -1441,7 +1441,7 @@
     m_errorMonitor->ClearState();
 
     // Create Pool w/ 1 Sampler descriptor, but try to alloc Uniform Buffer descriptor from it
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_SAMPLER;
         ds_type_count.descriptorCount = 1;
 
@@ -1450,8 +1450,8 @@
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.flags = 0;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -1501,7 +1501,7 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -1509,11 +1509,11 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
+        ds_pool_ci.poolSizeCount = 1;
         ds_pool_ci.flags = 0;
         // Not specifying VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT means
         // app can only call vkResetDescriptorPool on this pool.;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -1620,7 +1620,7 @@
     ASSERT_NO_FATAL_FAILURE(InitViewport());
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -1628,8 +1628,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -1788,7 +1788,7 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -1796,8 +1796,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -1889,15 +1889,15 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), VK_DESCRIPTOR_POOL_USAGE_NON_FREE, 1, &ds_pool_ci, NULL, &ds_pool);
@@ -2014,15 +2014,15 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -2123,15 +2123,15 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -2231,15 +2231,15 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -2316,7 +2316,7 @@
 	ia_ci.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
 
 	VkPipelineRasterizationStateCreateInfo rs_ci = {};
-	rs_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO;
+	rs_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
 	rs_ci.pNext = nullptr;
 
 	VkPipelineColorBlendStateCreateInfo cb_ci = {};
@@ -2389,15 +2389,15 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -2474,7 +2474,7 @@
     ia_ci.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
 
     VkPipelineRasterizationStateCreateInfo rs_ci = {};
-    rs_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO;
+    rs_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
     rs_ci.pNext = nullptr;
 
     VkPipelineColorBlendStateCreateInfo cb_ci = {};
@@ -2548,7 +2548,7 @@
 
     BeginCommandBuffer();
     // Don't care about RenderPass handle b/c error should be flagged before that
-    vkCmdBeginRenderPass(m_commandBuffer->GetBufferHandle(), NULL, VK_RENDER_PASS_CONTENTS_INLINE);
+    vkCmdBeginRenderPass(m_commandBuffer->GetBufferHandle(), NULL, VK_SUBPASS_CONTENTS_INLINE);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after binding NULL RenderPass.";
@@ -2575,7 +2575,7 @@
         rp_begin.renderPass = renderPass();
         rp_begin.framebuffer = framebuffer();
 
-    vkCmdBeginRenderPass(m_commandBuffer->GetBufferHandle(), &rp_begin, VK_RENDER_PASS_CONTENTS_INLINE);
+    vkCmdBeginRenderPass(m_commandBuffer->GetBufferHandle(), &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after binding RenderPass w/i an active RenderPass.";
@@ -2851,7 +2851,7 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
     //VkDescriptorSetObj descriptorSet(m_device);
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -2859,8 +2859,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -2947,7 +2947,7 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
     //VkDescriptorSetObj descriptorSet(m_device);
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -2955,8 +2955,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -3045,7 +3045,7 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
     //VkDescriptorSetObj descriptorSet(m_device);
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -3053,8 +3053,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -3142,7 +3142,7 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -3150,8 +3150,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -3238,7 +3238,7 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
     // TODO : Farm Descriptor setup code to helper function(s) to reduce copied code
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_SAMPLER;
         ds_type_count.descriptorCount = 1;
 
@@ -3246,8 +3246,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -3313,7 +3313,7 @@
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
         ds_type_count.descriptorCount = 1;
 
@@ -3321,8 +3321,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -3413,7 +3413,7 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
     //VkDescriptorSetObj descriptorSet(m_device);
-    VkDescriptorTypeCount ds_type_count[2] = {};
+    VkDescriptorPoolSize ds_type_count[2] = {};
         ds_type_count[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count[0].descriptorCount = 1;
         ds_type_count[1].type = VK_DESCRIPTOR_TYPE_SAMPLER;
@@ -3423,8 +3423,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 2;
-        ds_pool_ci.pTypeCounts = ds_type_count;
+        ds_pool_ci.poolSizeCount = 2;
+        ds_pool_ci.pPoolSizes = ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -3555,7 +3555,7 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
     ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
     ds_type_count.descriptorCount = 1;
 
@@ -3563,8 +3563,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -3647,7 +3647,7 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -3655,8 +3655,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -3752,7 +3752,7 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     m_errorMonitor->ClearState();
 
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         ds_type_count.descriptorCount = 1;
 
@@ -3760,8 +3760,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
@@ -5506,7 +5506,7 @@
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
-    VkDescriptorTypeCount ds_type_count = {};
+    VkDescriptorPoolSize ds_type_count = {};
         ds_type_count.type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
         ds_type_count.descriptorCount = 1;
 
@@ -5514,8 +5514,8 @@
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
         ds_pool_ci.maxSets = 1;
-        ds_pool_ci.typeCount = 1;
-        ds_pool_ci.pTypeCounts = &ds_type_count;
+        ds_pool_ci.poolSizeCount = 1;
+        ds_pool_ci.pPoolSizes = &ds_type_count;
 
     VkDescriptorPool ds_pool;
     err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index b9de073..5d0b582 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -763,7 +763,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BIND_ID,                      // binding ID
          sizeof(g_vbData[0]),              // stride;  Distance between vertices in bytes (0 = no advancement)
-         VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate;       // Rate at which binding is incremented
+         VK_VERTEX_INPUT_RATE_VERTEX // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attribs[2];
@@ -842,7 +842,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BUF_ID,                            // Binding ID
         sizeof(vb_data[0]),                     // stride;  Distance between vertices in bytes (0 = no advancement)
-        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_RATE_VERTEX       // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attrib;
@@ -860,7 +860,7 @@
 
     VkPipelineColorBlendAttachmentState att = {};
     att.blendEnable = VK_FALSE;
-    att.channelWriteMask = 0xf;
+    att.colorWriteMask = 0xf;
     pipelineobj.AddColorAttachment(1, &att);
 
     ASSERT_VK_SUCCESS(BeginCommandBuffer());
@@ -951,7 +951,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BIND_ID,                           // binding ID
         sizeof(g_vbData[0]),                    // stride;  Distance between vertices in bytes (0 = no advancement)
-        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_RATE_VERTEX       // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attribs[2];
@@ -1044,7 +1044,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BIND_ID,                           // binding ID
         sizeof(g_vbData[0]),                    // stride;  Distance between vertices in bytes (0 = no advancement)
-        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_RATE_VERTEX       // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attribs[1];
@@ -1132,7 +1132,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BIND_ID,                           // binding ID
         sizeof(g_vbData[0]),                    // stride;  Distance between vertices in bytes (0 = no advancement)
-        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_RATE_VERTEX       // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attribs[1];
@@ -1230,7 +1230,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BIND_ID,                           // binding ID
         sizeof(g_vbData[0]),                    // stride;  Distance between vertices in bytes (0 = no advancement)
-        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_RATE_VERTEX       // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attribs[1];
@@ -1319,7 +1319,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BIND_ID,                           // binding ID
         sizeof(g_vbData[0]),                    // stride;  Distance between vertices in bytes (0 = no advancement)
-        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_RATE_VERTEX       // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attribs[1];
@@ -1556,7 +1556,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BUF_ID,                            // Binding ID
         sizeof(g_vbData[0]),                    // stride;  Distance between vertices in bytes (0 = no advancement)
-        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_RATE_VERTEX       // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attribs[2];
@@ -1659,7 +1659,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BUF_ID,                            // Binding ID
         sizeof(vData[0]),                       // stride;  Distance between vertices in bytes (0 = no advancement)
-        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_RATE_VERTEX       // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attribs[2];
@@ -1752,7 +1752,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BUF_ID,                            // Binding ID
         sizeof(g_vbData[0]),                    // stride;  Distance between vertices in bytes (0 = no advancement)
-        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_RATE_VERTEX       // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attribs[2];
@@ -1855,10 +1855,10 @@
     ds_state.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
     ds_state.depthBoundsTestEnable = VK_FALSE;
     ds_state.stencilTestEnable = VK_FALSE;
-    ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
-    ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
-    ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
-    ds_state.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS;
+    ds_state.back.depthFailOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.failOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.passOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.compareOp = VK_COMPARE_OP_ALWAYS;
     ds_state.front = ds_state.back;
     pipelineobj.SetDepthStencil(&ds_state);
 
@@ -1869,7 +1869,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BUF_ID,                            // Binding ID
         sizeof(g_vbData[0]),                     // stride;  Distance between vertices in bytes (0 = no advancement)
-        VK_VERTEX_INPUT_STEP_RATE_VERTEX       // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_RATE_VERTEX       // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attribs[2];
@@ -2744,7 +2744,7 @@
     VkVertexInputBindingDescription vi_binding = {
         MESH_BIND_ID,                      // binding ID
         sizeof(g_vb_texture_Data[0]),               // stride;  Distance between vertices in bytes (0 = no advancement)
-        VK_VERTEX_INPUT_STEP_RATE_VERTEX  // stepRate;       // Rate at which binding is incremented
+        VK_VERTEX_INPUT_RATE_VERTEX  // inputRate;       // Rate at which binding is incremented
     };
 
     VkVertexInputAttributeDescription vi_attribs[2];
@@ -2766,10 +2766,10 @@
     ds_state.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
     ds_state.depthBoundsTestEnable = VK_FALSE;
     ds_state.stencilTestEnable = VK_FALSE;
-    ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
-    ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
-    ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
-    ds_state.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS;
+    ds_state.back.depthFailOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.failOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.passOp = VK_STENCIL_OP_KEEP;
+    ds_state.back.compareOp = VK_COMPARE_OP_ALWAYS;
     ds_state.front = ds_state.back;
     pipelineobj.SetDepthStencil(&ds_state);
 
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 34f5f2d..75e474f 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -214,9 +214,9 @@
     m_minDepthBounds = 0.f;
     m_maxDepthBounds = 1.f;
 
-    m_stencilCompareMask = 0xff;
-    m_stencilWriteMask = 0xff;
-    m_stencilReference = 0;
+    m_compareMask = 0xff;
+    m_writeMask = 0xff;
+    m_reference = 0;
 
     VkCommandPoolCreateInfo cmd_pool_info;
     cmd_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
@@ -233,8 +233,8 @@
 {
     VkViewport viewport;
     VkRect2D scissor;
-    viewport.originX  = 0;
-    viewport.originY  = 0;
+    viewport.x  = 0;
+    viewport.y  = 0;
     viewport.width    = 1.f * width;
     viewport.height   = 1.f * height;
     viewport.minDepth = 0.f;
@@ -439,7 +439,7 @@
 int VkDescriptorSetObj::AppendDummy()
 {
     /* request a descriptor but do not update it */
-    VkDescriptorTypeCount tc = {};
+    VkDescriptorPoolSize tc = {};
     tc.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
     tc.descriptorCount = 1;
     m_type_counts.push_back(tc);
@@ -453,7 +453,7 @@
            type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC ||
            type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER ||
            type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC);
-    VkDescriptorTypeCount tc = {};
+    VkDescriptorPoolSize tc = {};
     tc.type = type;
     tc.descriptorCount = 1;
     m_type_counts.push_back(tc);
@@ -466,7 +466,7 @@
 
 int VkDescriptorSetObj::AppendSamplerTexture( VkSamplerObj* sampler, VkTextureObj* texture)
 {
-    VkDescriptorTypeCount tc = {};
+    VkDescriptorPoolSize tc = {};
     tc.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
     tc.descriptorCount = 1;
     m_type_counts.push_back(tc);
@@ -496,9 +496,9 @@
     // create VkDescriptorPool
     VkDescriptorPoolCreateInfo pool = {};
     pool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-    pool.typeCount = m_type_counts.size();
+    pool.poolSizeCount = m_type_counts.size();
     pool.maxSets = 1;
-    pool.pTypeCounts = m_type_counts.data();
+    pool.pPoolSizes = m_type_counts.data();
     init(*m_device, pool);
 
     // create VkDescriptorSetLayout
@@ -815,10 +815,10 @@
     view.image = VK_NULL_HANDLE;
     view.viewType = VK_IMAGE_VIEW_TYPE_2D;
     view.format = tex_format;
-    view.channels.r = VK_CHANNEL_SWIZZLE_R;
-    view.channels.g = VK_CHANNEL_SWIZZLE_G;
-    view.channels.b = VK_CHANNEL_SWIZZLE_B;
-    view.channels.a = VK_CHANNEL_SWIZZLE_A;
+    view.channels.r = VK_COMPONENT_SWIZZLE_R;
+    view.channels.g = VK_COMPONENT_SWIZZLE_G;
+    view.channels.b = VK_COMPONENT_SWIZZLE_B;
+    view.channels.a = VK_COMPONENT_SWIZZLE_A;
     view.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
     view.subresourceRange.baseMipLevel = 0;
     view.subresourceRange.levelCount = 1;
@@ -1128,11 +1128,11 @@
     m_ia_state.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
     m_ia_state.primitiveRestartEnable = VK_FALSE;
 
-    m_rs_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO;
+    m_rs_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
     m_rs_state.pNext = VK_NULL_HANDLE;
     m_rs_state.depthClampEnable = VK_TRUE;
     m_rs_state.rasterizerDiscardEnable = VK_FALSE;
-    m_rs_state.fillMode = VK_FILL_MODE_SOLID;
+    m_rs_state.polygonMode = VK_POLYGON_MODE_FILL;
     m_rs_state.cullMode = VK_CULL_MODE_BACK_BIT;
     m_rs_state.frontFace = VK_FRONT_FACE_CLOCKWISE;
     m_rs_state.depthBiasEnable = VK_FALSE;
@@ -1172,14 +1172,14 @@
     m_ds_state.depthWriteEnable     = VK_FALSE;
     m_ds_state.depthBoundsTestEnable = VK_FALSE;
     m_ds_state.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
-    m_ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
-    m_ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
-    m_ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
-    m_ds_state.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS;
+    m_ds_state.back.depthFailOp = VK_STENCIL_OP_KEEP;
+    m_ds_state.back.failOp = VK_STENCIL_OP_KEEP;
+    m_ds_state.back.passOp = VK_STENCIL_OP_KEEP;
+    m_ds_state.back.compareOp = VK_COMPARE_OP_ALWAYS;
     m_ds_state.stencilTestEnable = VK_FALSE;
-    m_ds_state.back.stencilCompareMask = 0xff;
-    m_ds_state.back.stencilWriteMask = 0xff;
-    m_ds_state.back.stencilReference = 0;
+    m_ds_state.back.compareMask = 0xff;
+    m_ds_state.back.writeMask = 0xff;
+    m_ds_state.back.reference = 0;
     m_ds_state.minDepthBounds = 0.f;
     m_ds_state.maxDepthBounds = 1.f;
 
@@ -1505,7 +1505,7 @@
 
 void VkCommandBufferObj::BeginRenderPass(const VkRenderPassBeginInfo &info)
 {
-    vkCmdBeginRenderPass( handle(), &info, VK_RENDER_PASS_CONTENTS_INLINE);
+    vkCmdBeginRenderPass( handle(), &info, VK_SUBPASS_CONTENTS_INLINE);
 }
 
 void VkCommandBufferObj::EndRenderPass()
@@ -1555,23 +1555,23 @@
 
 void VkCommandBufferObj::SetStencilReadMask(
     VkStencilFaceFlags                  faceMask,
-    uint32_t                            stencilCompareMask)
+    uint32_t                            compareMask)
 {
-    vkCmdSetStencilCompareMask( handle(), faceMask, stencilCompareMask);
+    vkCmdSetStencilCompareMask( handle(), faceMask, compareMask);
 }
 
 void VkCommandBufferObj::SetStencilWriteMask(
     VkStencilFaceFlags                  faceMask,
-    uint32_t                            stencilWriteMask)
+    uint32_t                            writeMask)
 {
-    vkCmdSetStencilWriteMask( handle(), faceMask, stencilWriteMask);
+    vkCmdSetStencilWriteMask( handle(), faceMask, writeMask);
 }
 
 void VkCommandBufferObj::SetStencilReference(
     VkStencilFaceFlags                  faceMask,
-    uint32_t                            stencilReference)
+    uint32_t                            reference)
 {
-    vkCmdSetStencilReference( handle(), faceMask, stencilReference);
+    vkCmdSetStencilReference( handle(), faceMask, reference);
 }
 
 void VkCommandBufferObj::AddRenderTarget(VkImageObj *renderTarget)
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index 0e42cfd..5382210 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -119,9 +119,9 @@
     float                               m_blendConstants[4];
     float                               m_minDepthBounds;
     float                               m_maxDepthBounds;
-    uint32_t                            m_stencilCompareMask;
-    uint32_t                            m_stencilWriteMask;
-    uint32_t                            m_stencilReference;
+    uint32_t                            m_compareMask;
+    uint32_t                            m_writeMask;
+    uint32_t                            m_reference;
     std::vector<VkClearValue>           m_renderPassClearValues;
     VkRenderPassBeginInfo               m_renderPassBeginInfo;
     vector<VkImageObj*>                 m_renderTargets;
@@ -195,9 +195,9 @@
     void SetDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
     void SetBlendConstants(const float blendConstants[4]);
     void SetDepthBounds(float minDepthBounds, float maxDepthBounds);
-    void SetStencilReadMask(VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
-    void SetStencilWriteMask(VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
-    void SetStencilReference(VkStencilFaceFlags faceMask, uint32_t stencilReference);
+    void SetStencilReadMask(VkStencilFaceFlags faceMask, uint32_t compareMask);
+    void SetStencilWriteMask(VkStencilFaceFlags faceMask, uint32_t writeMask);
+    void SetStencilReference(VkStencilFaceFlags faceMask, uint32_t reference);
     void UpdateBuffer(VkBuffer buffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t *pData);
     void CopyImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
     void ResolveImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
@@ -313,10 +313,10 @@
             createView.image = handle();
             createView.viewType =  VK_IMAGE_VIEW_TYPE_2D;
             createView.format = format;
-            createView.channels.r = VK_CHANNEL_SWIZZLE_R;
-            createView.channels.g = VK_CHANNEL_SWIZZLE_G;
-            createView.channels.b = VK_CHANNEL_SWIZZLE_B;
-            createView.channels.a = VK_CHANNEL_SWIZZLE_A;
+            createView.channels.r = VK_COMPONENT_SWIZZLE_R;
+            createView.channels.g = VK_COMPONENT_SWIZZLE_G;
+            createView.channels.b = VK_COMPONENT_SWIZZLE_B;
+            createView.channels.a = VK_COMPONENT_SWIZZLE_A;
             createView.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
             createView.flags = 0;
             m_targetView.init(*m_device, createView);
@@ -390,7 +390,7 @@
 
 protected:
     VkDeviceObj                        *m_device;
-    vector<VkDescriptorTypeCount>       m_type_counts;
+    vector<VkDescriptorPoolSize>       m_type_counts;
     int                                 m_nextSlot;
 
     vector<VkDescriptorImageInfo>       m_imageSamplerDescriptors;
@@ -429,7 +429,7 @@
     {
         VkPipelineColorBlendAttachmentState att = {};
         att.blendEnable = VK_FALSE;
-        att.channelWriteMask = 0xf;
+        att.colorWriteMask = 0xf;
         AddColorAttachment(0, &att);
     }
 
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index 610374a..f288e67 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -334,7 +334,7 @@
                 queues_[COMPUTE].push_back(new Queue(queue, i));
             }
 
-            if (queue_props[i].queueFlags & VK_QUEUE_DMA_BIT) {
+            if (queue_props[i].queueFlags & VK_QUEUE_TRANSFER_BIT) {
                 queues_[DMA].push_back(new Queue(queue, i));
             }
         }
@@ -594,7 +594,7 @@
     return data;
 }
 
-VkSubresourceLayout Image::subresource_layout(const VkImageSubresourceCopy &subrescopy) const
+VkSubresourceLayout Image::subresource_layout(const VkImageSubresourceLayers &subrescopy) const
 {
     VkSubresourceLayout data;
     VkImageSubresource subres = subresource(image_aspect(subrescopy.aspect), subrescopy.mipLevel, subrescopy.baseArrayLayer);
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 6bfc416..2af0780 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -391,7 +391,7 @@
 
     // vkGetImageSubresourceLayout()
     VkSubresourceLayout subresource_layout(const VkImageSubresource &subres) const;
-    VkSubresourceLayout subresource_layout(const VkImageSubresourceCopy &subres) const;
+    VkSubresourceLayout subresource_layout(const VkImageSubresourceLayers &subres) const;
 
     bool transparent() const;
     bool copyable() const { return (format_features_ & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT); }
@@ -421,8 +421,8 @@
     static VkImageAspectFlagBits image_aspect(VkImageAspectFlags flags);
     static VkImageSubresource subresource(VkImageAspectFlagBits aspect, uint32_t mip_level, uint32_t array_layer);
     static VkImageSubresource subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer);
-    static VkImageSubresourceCopy subresource(VkImageAspectFlagBits aspect, uint32_t mip_level, uint32_t array_layer, uint32_t array_size);
-    static VkImageSubresourceCopy subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer, uint32_t array_size);
+    static VkImageSubresourceLayers subresource(VkImageAspectFlagBits aspect, uint32_t mip_level, uint32_t array_layer, uint32_t array_size);
+    static VkImageSubresourceLayers subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer, uint32_t array_size);
     static VkImageSubresourceRange subresource_range(VkImageAspectFlags aspect_mask, uint32_t base_mip_level, uint32_t mip_levels,
                                                      uint32_t base_array_layer, uint32_t num_layers);
     static VkImageSubresourceRange subresource_range(const VkImageCreateInfo &info, VkImageAspectFlags aspect_mask);
@@ -692,9 +692,9 @@
     return subresource(image_aspect(range.aspectMask), range.baseMipLevel + mip_level, range.baseArrayLayer + array_layer);
 }
 
-inline VkImageSubresourceCopy Image::subresource(VkImageAspectFlagBits aspect, uint32_t mip_level, uint32_t array_layer, uint32_t array_size)
+inline VkImageSubresourceLayers Image::subresource(VkImageAspectFlagBits aspect, uint32_t mip_level, uint32_t array_layer, uint32_t array_size)
 {
-    VkImageSubresourceCopy subres = {};
+    VkImageSubresourceLayers subres = {};
     subres.aspect = aspect;
     subres.mipLevel = mip_level;
     subres.baseArrayLayer = array_layer;
@@ -723,7 +723,7 @@
     return VK_IMAGE_ASPECT_COLOR_BIT;
 }
 
-inline VkImageSubresourceCopy Image::subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer, uint32_t array_size)
+inline VkImageSubresourceLayers Image::subresource(const VkImageSubresourceRange &range, uint32_t mip_level, uint32_t array_layer, uint32_t array_size)
 {
     return subresource(image_aspect(range.aspectMask), range.baseMipLevel + mip_level, range.baseArrayLayer + array_layer, array_size);
 }
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 93319dd..b7d0f82 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -157,7 +157,7 @@
         if "VkFormat" == vk_type:
             if cpp:
                 return ("%p", "&%s" % name)
-            return ("{%s.channelFormat = %%s, %s.numericFormat = %%s}" % (name, name), "string_VK_CHANNEL_FORMAT(%s.channelFormat), string_VK_FORMAT_RANGE_SIZE(%s.numericFormat)" % (name, name))
+            return ("{%s.channelFormat = %%s, %s.numericFormat = %%s}" % (name, name), "string_VK_COLOR_COMPONENT_FORMAT(%s.channelFormat), string_VK_FORMAT_RANGE_SIZE(%s.numericFormat)" % (name, name))
         if output_param:
             return ("%p", "(void*)*%s" % name)
         if vk_helper.is_type(vk_type, 'struct') and '*' not in vk_type:
diff --git a/vulkan.py b/vulkan.py
index 9336713..6ccd8f2 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -761,17 +761,17 @@
         Proto("void", "CmdSetStencilCompareMask",
             [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkStencilFaceFlags", "faceMask"),
-             Param("uint32_t", "stencilCompareMask")]),
+             Param("uint32_t", "compareMask")]),
 
         Proto("void", "CmdSetStencilWriteMask",
             [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkStencilFaceFlags", "faceMask"),
-             Param("uint32_t", "stencilWriteMask")]),
+             Param("uint32_t", "writeMask")]),
 
         Proto("void", "CmdSetStencilReference",
             [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkStencilFaceFlags", "faceMask"),
-             Param("uint32_t", "stencilReference")]),
+             Param("uint32_t", "reference")]),
 
         Proto("void", "CmdBindDescriptorSets",
             [Param("VkCommandBuffer", "commandBuffer"),
@@ -995,11 +995,11 @@
         Proto("void", "CmdBeginRenderPass",
             [Param("VkCommandBuffer", "commandBuffer"),
              Param("const VkRenderPassBeginInfo*", "pRenderPassBegin"),
-             Param("VkRenderPassContents", "contents")]),
+             Param("VkSubpassContents", "contents")]),
 
         Proto("void", "CmdNextSubpass",
             [Param("VkCommandBuffer", "commandBuffer"),
-             Param("VkRenderPassContents", "contents")]),
+             Param("VkSubpassContents", "contents")]),
 
         Proto("void", "CmdEndRenderPass",
             [Param("VkCommandBuffer", "commandBuffer")]),