diff --git a/docs/vk_full_pipeline_ds.dot b/docs/vk_full_pipeline_ds.dot
index 15f0c26..2465432 100644
--- a/docs/vk_full_pipeline_ds.dot
+++ b/docs/vk_full_pipeline_ds.dot
@@ -21,7 +21,7 @@
 label = <<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0"> <TR><TD COLSPAN="2" PORT="f0">VkPipelineRsStateCreateInfo</TD></TR><TR><TD>VkStructureType</TD><TD>sType=<BR/>VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO</TD></TR> <TR><TD>const void*</TD><TD PORT="f2">pNext</TD></TR> <TR><TD>bool32_t</TD><TD>depthClipEnable</TD></TR> <TR><TD>bool32_t</TD><TD>rasterizerDiscardEnable</TD></TR> <TR><TD>float</TD><TD>pointSize</TD></TR> </TABLE>>
 ];
 "VkPipelineCbStateCreateInfo_" [
-label = <<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0"> <TR><TD COLSPAN="2" PORT="f0">VK_PIPELINE_CB_STATE</TD></TR><TR><TD>VkStructureType</TD><TD>sType=<BR/>VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO</TD></TR> <TR><TD>const void*</TD><TD PORT="f2">pNext</TD></TR> <TR><TD>bool32_t</TD><TD>alphaToCoverageEnable</TD></TR> <TR><TD>bool32_t</TD><TD>dualSourceBlendEnable</TD></TR> <TR><TD>VkLogicOp</TD><TD>logicOp</TD></TR> <TR><TD>VkPipelineCbAttachmentState</TD><TD>attachment</TD></TR> </TABLE>>
+label = <<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0"> <TR><TD COLSPAN="2" PORT="f0">VK_PIPELINE_CB_STATE</TD></TR><TR><TD>VkStructureType</TD><TD>sType=<BR/>VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO</TD></TR> <TR><TD>const void*</TD><TD PORT="f2">pNext</TD></TR> <TR><TD>bool32_t</TD><TD>alphaToCoverageEnable</TD></TR> <TR><TD>bool32_t</TD><TD>dualSrcBlendEnable</TD></TR> <TR><TD>VkLogicOp</TD><TD>logicOp</TD></TR> <TR><TD>VkPipelineCbAttachmentState</TD><TD>attachment</TD></TR> </TABLE>>
 ];
 "_VK_PIPELINE_DB_STATE_CREATE_INFO" [
 label = <<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0"> <TR><TD COLSPAN="2" PORT="f0">VK_PIPELINE_DB_STATE_CREATE_INFO</TD></TR><TR><TD>VkStructureType</TD><TD>sType=<BR/>VK_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO</TD></TR> <TR><TD>const void*</TD><TD PORT="f2">pNext</TD></TR> <TR><TD>VkFormat</TD><TD>format</TD></TR> </TABLE>>
diff --git a/docs/vk_graphics_pipeline.dot b/docs/vk_graphics_pipeline.dot
index c659cff..946a252 100644
--- a/docs/vk_graphics_pipeline.dot
+++ b/docs/vk_graphics_pipeline.dot
@@ -21,7 +21,7 @@
 label = <<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0"> <TR><TD COLSPAN="2" PORT="f0">VkPipelineRsStateCreateInfo</TD></TR><TR><TD>VkStructureType</TD><TD>sType=<BR/>VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO</TD></TR> <TR><TD>const void*</TD><TD PORT="f2">pNext</TD></TR> <TR><TD>bool32_t</TD><TD>depthClipEnable</TD></TR> <TR><TD>bool32_t</TD><TD>rasterizerDiscardEnable</TD></TR> <TR><TD>float</TD><TD>pointSize</TD></TR> </TABLE>>
 ];
 "VkPipelineCbStateCreateInfo_" [
-label = <<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0"> <TR><TD COLSPAN="2" PORT="f0">VK_PIPELINE_CB_STATE</TD></TR><TR><TD>VkStructureType</TD><TD>sType=<BR/>VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO</TD></TR> <TR><TD>const void*</TD><TD PORT="f2">pNext</TD></TR> <TR><TD>bool32_t</TD><TD>alphaToCoverageEnable</TD></TR> <TR><TD>bool32_t</TD><TD>dualSourceBlendEnable</TD></TR> <TR><TD>VkLogicOp</TD><TD>logicOp</TD></TR> <TR><TD>VkPipelineCbAttachmentState</TD><TD>attachment</TD></TR> </TABLE>>
+label = <<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0"> <TR><TD COLSPAN="2" PORT="f0">VK_PIPELINE_CB_STATE</TD></TR><TR><TD>VkStructureType</TD><TD>sType=<BR/>VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO</TD></TR> <TR><TD>const void*</TD><TD PORT="f2">pNext</TD></TR> <TR><TD>bool32_t</TD><TD>alphaToCoverageEnable</TD></TR> <TR><TD>bool32_t</TD><TD>dualSrcBlendEnable</TD></TR> <TR><TD>VkLogicOp</TD><TD>logicOp</TD></TR> <TR><TD>VkPipelineCbAttachmentState</TD><TD>attachment</TD></TR> </TABLE>>
 ];
 "_VK_PIPELINE_DB_STATE_CREATE_INFO" [
 label = <<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0"> <TR><TD COLSPAN="2" PORT="f0">VK_PIPELINE_DB_STATE_CREATE_INFO</TD></TR><TR><TD>VkStructureType</TD><TD>sType=<BR/>VK_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO</TD></TR> <TR><TD>const void*</TD><TD PORT="f2">pNext</TD></TR> <TR><TD>VkFormat</TD><TD>format</TD></TR> </TABLE>>
diff --git a/include/vk_debug_marker_lunarg.h b/include/vk_debug_marker_lunarg.h
index c457959..cc53cc7 100644
--- a/include/vk_debug_marker_lunarg.h
+++ b/include/vk_debug_marker_lunarg.h
@@ -60,8 +60,8 @@
 // ------------------------------------------------------------------------------------------------
 // API functions
 
-typedef void (VKAPI *PFN_vkCmdDbgMarkerBegin)(VkCmdBuffer cmdBuffer, const char* pMarker);
-typedef void (VKAPI *PFN_vkCmdDbgMarkerEnd)(VkCmdBuffer cmdBuffer);
+typedef void (VKAPI *PFN_vkCmdDbgMarkerBegin)(VkCommandBuffer commandBuffer, const char* pMarker);
+typedef void (VKAPI *PFN_vkCmdDbgMarkerEnd)(VkCommandBuffer commandBuffer);
 typedef VkResult (VKAPI *PFN_vkDbgSetObjectTag)(VkDevice device, VkDbgObjectType objType, uint64_t object, size_t tagSize, const void* pTag);
 typedef VkResult (VKAPI *PFN_vkDbgSetObjectName)(VkDevice device, VkDbgObjectType objType, uint64_t object, size_t nameSize, const char* pName);
 
@@ -69,11 +69,11 @@
 
 // DebugMarker extension entrypoints
 void VKAPI vkCmdDbgMarkerBegin(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     const char*                         pMarker);
 
 void VKAPI vkCmdDbgMarkerEnd(
-    VkCmdBuffer                         cmdBuffer);
+    VkCommandBuffer                         commandBuffer);
 
 VkResult VKAPI vkDbgSetObjectTag(
     VkDevice                            device,
diff --git a/include/vk_debug_report_lunarg.h b/include/vk_debug_report_lunarg.h
index 23bb63c..04c6fd5 100644
--- a/include/vk_debug_report_lunarg.h
+++ b/include/vk_debug_report_lunarg.h
@@ -74,16 +74,16 @@
     VK_OBJECT_TYPE_RENDER_PASS = 25,
     VK_OBJECT_TYPE_PIPELINE_CACHE = 26,
     VK_OBJECT_TYPE_SWAPCHAIN_KHR = 27,
-    VK_OBJECT_TYPE_CMD_POOL = 28,
+    VK_OBJECT_TYPE_COMMAND_POOL = 28,
     VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE,
-    VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_CMD_POOL,
-    VK_OBJECT_TYPE_NUM = (VK_OBJECT_TYPE_CMD_POOL - VK_OBJECT_TYPE_INSTANCE + 1),
+    VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL,
+    VK_OBJECT_TYPE_NUM = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_INSTANCE + 1),
     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkDbgObjectType;
 
 #define VK_DEBUG_REPORT_EXTENSION_NAME "DEBUG_REPORT"
 
-VK_DEFINE_NONDISP_HANDLE(VkDbgMsgCallback)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDbgMsgCallback)
 
 // ------------------------------------------------------------------------------------------------
 // Enumerations
diff --git a/include/vk_ext_khr_device_swapchain.h b/include/vk_ext_khr_device_swapchain.h
index 3bf73c8..af95ff0 100644
--- a/include/vk_ext_khr_device_swapchain.h
+++ b/include/vk_ext_khr_device_swapchain.h
@@ -41,7 +41,7 @@
 // ------------------------------------------------------------------------------------------------
 // Objects
 
-VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR);
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR);
 
 // ------------------------------------------------------------------------------------------------
 // Enumeration constants
diff --git a/include/vk_layer.h b/include/vk_layer.h
index 8fc494f..2035a8b 100644
--- a/include/vk_layer.h
+++ b/include/vk_layer.h
@@ -35,7 +35,7 @@
     PFN_vkQueueSubmit QueueSubmit;
     PFN_vkQueueWaitIdle QueueWaitIdle;
     PFN_vkDeviceWaitIdle DeviceWaitIdle;
-    PFN_vkAllocMemory AllocMemory;
+    PFN_vkAllocateMemory AllocateMemory;
     PFN_vkFreeMemory FreeMemory;
     PFN_vkMapMemory MapMemory;
     PFN_vkUnmapMemory UnmapMemory;
@@ -92,7 +92,7 @@
     PFN_vkCreateDescriptorPool CreateDescriptorPool;
     PFN_vkDestroyDescriptorPool DestroyDescriptorPool;
     PFN_vkResetDescriptorPool ResetDescriptorPool;
-    PFN_vkAllocDescriptorSets AllocDescriptorSets;
+    PFN_vkAllocateDescriptorSets AllocateDescriptorSets;
     PFN_vkFreeDescriptorSets FreeDescriptorSets;
     PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
     PFN_vkCreateFramebuffer CreateFramebuffer;
@@ -103,7 +103,7 @@
     PFN_vkCreateCommandPool CreateCommandPool;
     PFN_vkDestroyCommandPool DestroyCommandPool;
     PFN_vkResetCommandPool ResetCommandPool;
-    PFN_vkAllocCommandBuffers AllocCommandBuffers;
+    PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
     PFN_vkFreeCommandBuffers FreeCommandBuffers;
     PFN_vkBeginCommandBuffer BeginCommandBuffer;
     PFN_vkEndCommandBuffer EndCommandBuffer;
diff --git a/include/vulkan.h b/include/vulkan.h
index 8c7977c..1a63739 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -52,9 +52,9 @@
 
 
 #if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T *obj;
+        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(obj) typedef struct obj##_T *obj;
 #else
-        #define VK_DEFINE_NONDISP_HANDLE(obj) typedef uint64_t obj;
+        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(obj) typedef uint64_t obj;
 #endif
         
 
@@ -68,28 +68,28 @@
 VK_DEFINE_HANDLE(VkPhysicalDevice)
 VK_DEFINE_HANDLE(VkDevice)
 VK_DEFINE_HANDLE(VkQueue)
-VK_DEFINE_NONDISP_HANDLE(VkSemaphore)
-VK_DEFINE_HANDLE(VkCmdBuffer)
-VK_DEFINE_NONDISP_HANDLE(VkFence)
-VK_DEFINE_NONDISP_HANDLE(VkDeviceMemory)
-VK_DEFINE_NONDISP_HANDLE(VkBuffer)
-VK_DEFINE_NONDISP_HANDLE(VkImage)
-VK_DEFINE_NONDISP_HANDLE(VkEvent)
-VK_DEFINE_NONDISP_HANDLE(VkQueryPool)
-VK_DEFINE_NONDISP_HANDLE(VkBufferView)
-VK_DEFINE_NONDISP_HANDLE(VkImageView)
-VK_DEFINE_NONDISP_HANDLE(VkShaderModule)
-VK_DEFINE_NONDISP_HANDLE(VkShader)
-VK_DEFINE_NONDISP_HANDLE(VkPipelineCache)
-VK_DEFINE_NONDISP_HANDLE(VkPipelineLayout)
-VK_DEFINE_NONDISP_HANDLE(VkRenderPass)
-VK_DEFINE_NONDISP_HANDLE(VkPipeline)
-VK_DEFINE_NONDISP_HANDLE(VkDescriptorSetLayout)
-VK_DEFINE_NONDISP_HANDLE(VkSampler)
-VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool)
-VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet)
-VK_DEFINE_NONDISP_HANDLE(VkFramebuffer)
-VK_DEFINE_NONDISP_HANDLE(VkCmdPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
+VK_DEFINE_HANDLE(VkCommandBuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShader)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
 
 #define VK_LOD_CLAMP_NONE                 1000.0f
 #define VK_REMAINING_MIP_LEVELS           (~0U)
@@ -171,9 +171,9 @@
     VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 37,
     VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 38,
     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 39,
-    VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 40,
-    VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 41,
-    VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 42,
+    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 40,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 41,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
     VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
@@ -187,16 +187,16 @@
 } VkStructureType;
 
 typedef enum {
-    VK_SYSTEM_ALLOC_SCOPE_FUNCTION = 0,
-    VK_SYSTEM_ALLOC_SCOPE_OBJECT = 1,
-    VK_SYSTEM_ALLOC_SCOPE_CACHE = 2,
-    VK_SYSTEM_ALLOC_SCOPE_DEVICE = 3,
-    VK_SYSTEM_ALLOC_SCOPE_INSTANCE = 4,
-    VK_SYSTEM_ALLOC_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_SCOPE_FUNCTION,
-    VK_SYSTEM_ALLOC_SCOPE_END_RANGE = VK_SYSTEM_ALLOC_SCOPE_INSTANCE,
-    VK_SYSTEM_ALLOC_SCOPE_NUM = (VK_SYSTEM_ALLOC_SCOPE_INSTANCE - VK_SYSTEM_ALLOC_SCOPE_FUNCTION + 1),
-    VK_SYSTEM_ALLOC_SCOPE_MAX_ENUM = 0x7FFFFFFF
-} VkSystemAllocScope;
+    VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION = 0,
+    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
+    VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
+    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
+    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
+    VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION,
+    VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
+    VK_SYSTEM_ALLOCATION_SCOPE_NUM = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION + 1),
+    VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
+} VkSystemAllocationScope;
 
 typedef enum {
     VK_INTERNAL_ALLOC_TYPE_EXECUTABLE = 0,
@@ -383,7 +383,7 @@
     VK_FORMAT_B10G10R10A2_SINT = 173,
     VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
     VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT,
-    VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1),
+    VK_FORMAT_RANGE_SIZE = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1),
     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
 } VkFormat;
 
@@ -393,7 +393,7 @@
     VK_IMAGE_TYPE_3D = 2,
     VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
     VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
-    VK_IMAGE_TYPE_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
+    VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
     VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkImageType;
 
@@ -444,8 +444,8 @@
     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
-    VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 6,
-    VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7,
+    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
+    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
     VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
     VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
     VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
@@ -497,10 +497,10 @@
     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
-    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 6,
-    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7,
-    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8,
-    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9,
+    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
+    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
     VK_PRIMITIVE_TOPOLOGY_PATCH = 10,
     VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
     VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH,
@@ -519,11 +519,11 @@
 } VkFillMode;
 
 typedef enum {
-    VK_FRONT_FACE_CCW = 0,
-    VK_FRONT_FACE_CW = 1,
-    VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW,
-    VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW,
-    VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1),
+    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
+    VK_FRONT_FACE_CLOCKWISE = 1,
+    VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
+    VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
+    VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
     VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
 } VkFrontFace;
 
@@ -531,10 +531,10 @@
     VK_COMPARE_OP_NEVER = 0,
     VK_COMPARE_OP_LESS = 1,
     VK_COMPARE_OP_EQUAL = 2,
-    VK_COMPARE_OP_LESS_EQUAL = 3,
+    VK_COMPARE_OP_LESS_OR_EQUAL = 3,
     VK_COMPARE_OP_GREATER = 4,
     VK_COMPARE_OP_NOT_EQUAL = 5,
-    VK_COMPARE_OP_GREATER_EQUAL = 6,
+    VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
     VK_COMPARE_OP_ALWAYS = 7,
     VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
     VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
@@ -546,14 +546,14 @@
     VK_STENCIL_OP_KEEP = 0,
     VK_STENCIL_OP_ZERO = 1,
     VK_STENCIL_OP_REPLACE = 2,
-    VK_STENCIL_OP_INC_CLAMP = 3,
-    VK_STENCIL_OP_DEC_CLAMP = 4,
+    VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
+    VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
     VK_STENCIL_OP_INVERT = 5,
-    VK_STENCIL_OP_INC_WRAP = 6,
-    VK_STENCIL_OP_DEC_WRAP = 7,
+    VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
+    VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
     VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
-    VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP,
-    VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1),
+    VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
+    VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
     VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
 } VkStencilOp;
 
@@ -563,11 +563,11 @@
     VK_LOGIC_OP_AND_REVERSE = 2,
     VK_LOGIC_OP_COPY = 3,
     VK_LOGIC_OP_AND_INVERTED = 4,
-    VK_LOGIC_OP_NOOP = 5,
+    VK_LOGIC_OP_NO_OP = 5,
     VK_LOGIC_OP_XOR = 6,
     VK_LOGIC_OP_OR = 7,
     VK_LOGIC_OP_NOR = 8,
-    VK_LOGIC_OP_EQUIV = 9,
+    VK_LOGIC_OP_EQUIVALENT = 9,
     VK_LOGIC_OP_INVERT = 10,
     VK_LOGIC_OP_OR_REVERSE = 11,
     VK_LOGIC_OP_COPY_INVERTED = 12,
@@ -585,12 +585,12 @@
     VK_BLEND_ONE = 1,
     VK_BLEND_SRC_COLOR = 2,
     VK_BLEND_ONE_MINUS_SRC_COLOR = 3,
-    VK_BLEND_DEST_COLOR = 4,
-    VK_BLEND_ONE_MINUS_DEST_COLOR = 5,
+    VK_BLEND_DST_COLOR = 4,
+    VK_BLEND_ONE_MINUS_DST_COLOR = 5,
     VK_BLEND_SRC_ALPHA = 6,
     VK_BLEND_ONE_MINUS_SRC_ALPHA = 7,
-    VK_BLEND_DEST_ALPHA = 8,
-    VK_BLEND_ONE_MINUS_DEST_ALPHA = 9,
+    VK_BLEND_DST_ALPHA = 8,
+    VK_BLEND_ONE_MINUS_DST_ALPHA = 9,
     VK_BLEND_CONSTANT_COLOR = 10,
     VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11,
     VK_BLEND_CONSTANT_ALPHA = 12,
@@ -630,7 +630,7 @@
     VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
     VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
     VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
-    VK_DYNAMIC_STATE_NUM = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
+    VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
 } VkDynamicState;
 
@@ -720,18 +720,18 @@
     VK_PIPELINE_BIND_POINT_COMPUTE = 1,
     VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
     VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
-    VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
+    VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
 } VkPipelineBindPoint;
 
 typedef enum {
-    VK_CMD_BUFFER_LEVEL_PRIMARY = 0,
-    VK_CMD_BUFFER_LEVEL_SECONDARY = 1,
-    VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY,
-    VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY,
-    VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1),
-    VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
-} VkCmdBufferLevel;
+    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
+    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
+    VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+    VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
+    VK_COMMAND_BUFFER_LEVEL_NUM = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
+    VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
+} VkCommandBufferLevel;
 
 typedef enum {
     VK_INDEX_TYPE_UINT16 = 0,
@@ -744,10 +744,10 @@
 
 typedef enum {
     VK_RENDER_PASS_CONTENTS_INLINE = 0,
-    VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1,
+    VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
     VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE,
-    VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS,
-    VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1),
+    VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
+    VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1),
     VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
 } VkRenderPassContents;
 
@@ -764,14 +764,14 @@
     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
     VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
-    VK_FORMAT_FEATURE_BLIT_SOURCE_BIT = 0x00000400,
-    VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT = 0x00000800,
+    VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
+    VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
 } VkFormatFeatureFlagBits;
 typedef VkFlags VkFormatFeatureFlags;
 
 typedef enum {
-    VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
-    VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
+    VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+    VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
     VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
     VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
     VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
@@ -885,8 +885,8 @@
 typedef VkFlags VkBufferCreateFlags;
 
 typedef enum {
-    VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
-    VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
+    VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+    VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
     VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
     VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
     VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
@@ -1014,27 +1014,27 @@
 typedef VkFlags VkDependencyFlags;
 
 typedef enum {
-    VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
-    VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
-} VkCmdPoolCreateFlagBits;
-typedef VkFlags VkCmdPoolCreateFlags;
+    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
+    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
+} VkCommandPoolCreateFlagBits;
+typedef VkFlags VkCommandPoolCreateFlags;
 
 typedef enum {
-    VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
-} VkCmdPoolResetFlagBits;
-typedef VkFlags VkCmdPoolResetFlags;
+    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+} VkCommandPoolResetFlagBits;
+typedef VkFlags VkCommandPoolResetFlags;
 
 typedef enum {
-    VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
-    VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
-    VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
-} VkCmdBufferUsageFlagBits;
-typedef VkFlags VkCmdBufferUsageFlags;
+    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
+    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
+    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
+} VkCommandBufferUsageFlagBits;
+typedef VkFlags VkCommandBufferUsageFlags;
 
 typedef enum {
-    VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
-} VkCmdBufferResetFlagBits;
-typedef VkFlags VkCmdBufferResetFlags;
+    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+} VkCommandBufferResetFlagBits;
+typedef VkFlags VkCommandBufferResetFlags;
 
 typedef enum {
     VK_STENCIL_FACE_NONE = 0,
@@ -1053,38 +1053,38 @@
     void*              pUserData,
     size_t             size,
     size_t             alignment,
-    VkSystemAllocScope allocScope);
+    VkSystemAllocationScope allocationScope);
 
 typedef void* (VKAPI *PFN_vkReallocFunction)(
     void*              pUserData,
     void*              pOriginal,
     size_t             size,
     size_t             alignment,
-    VkSystemAllocScope allocScope);
+    VkSystemAllocationScope allocationScope);
 
 typedef void (VKAPI *PFN_vkFreeFunction)(
     void*                           pUserData,
-    void*                           pMem);
+    void*                           pMemory);
 
 typedef void (VKAPI *PFN_vkInternalAllocNotification)(
     void*              pUserData,
     size_t                           size,
-    VkInternalAllocType              allocType,
-    VkSystemAllocScope               allocScope);
+    VkInternalAllocType              allocationType,
+    VkSystemAllocationScope               allocationScope);
 
 typedef void (VKAPI *PFN_vkInternalFreeNotification)(
     void*              pUserData,
     size_t                           size,
-    VkInternalAllocType              allocType,
-    VkSystemAllocScope               allocScope);
+    VkInternalAllocType              allocationType,
+    VkSystemAllocationScope               allocationScope);
 
 typedef void (VKAPI *PFN_vkVoidFunction)(void);
 
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    const char*                                 pAppName;
-    uint32_t                                    appVersion;
+    const char*                                 pApplicationName;
+    uint32_t                                    applicationVersion;
     const char*                                 pEngineName;
     uint32_t                                    engineVersion;
     uint32_t                                    apiVersion;
@@ -1094,7 +1094,7 @@
     VkStructureType                             sType;
     const void*                                 pNext;
     VkInstanceCreateFlags                       flags;
-    const VkApplicationInfo*                    pAppInfo;
+    const VkApplicationInfo*                    pApplicationInfo;
     uint32_t                                    enabledLayerNameCount;
     const char*const*                           ppEnabledLayerNames;
     uint32_t                                    enabledExtensionNameCount;
@@ -1103,12 +1103,12 @@
 
 typedef struct {
     void*                                       pUserData;
-    PFN_vkAllocFunction                         pfnAlloc;
-    PFN_vkReallocFunction                       pfnRealloc;
+    PFN_vkAllocFunction                         pfnAllocation;
+    PFN_vkReallocFunction                       pfnReallocation;
     PFN_vkFreeFunction                          pfnFree;
     PFN_vkInternalAllocNotification             pfnInternalAlloc;
     PFN_vkInternalFreeNotification              pfnInternalFree;
-} VkAllocCallbacks;
+} VkAllocationCallbacks;
 
 typedef struct {
     VkBool32                                    robustBufferAccess;
@@ -1118,7 +1118,7 @@
     VkBool32                                    geometryShader;
     VkBool32                                    tessellationShader;
     VkBool32                                    sampleRateShading;
-    VkBool32                                    dualSourceBlend;
+    VkBool32                                    dualSrcBlend;
     VkBool32                                    logicOp;
     VkBool32                                    multiDrawIndirect;
     VkBool32                                    depthClamp;
@@ -1215,7 +1215,7 @@
     uint32_t                                    maxVertexInputAttributeOffset;
     uint32_t                                    maxVertexInputBindingStride;
     uint32_t                                    maxVertexOutputComponents;
-    uint32_t                                    maxTessellationGenLevel;
+    uint32_t                                    maxTessellationGenerationLevel;
     uint32_t                                    maxTessellationPatchSize;
     uint32_t                                    maxTessellationControlPerVertexInputComponents;
     uint32_t                                    maxTessellationControlPerVertexOutputComponents;
@@ -1230,7 +1230,7 @@
     uint32_t                                    maxGeometryTotalOutputComponents;
     uint32_t                                    maxFragmentInputComponents;
     uint32_t                                    maxFragmentOutputAttachments;
-    uint32_t                                    maxFragmentDualSourceAttachments;
+    uint32_t                                    maxFragmentDualSrcAttachments;
     uint32_t                                    maxFragmentCombinedOutputResources;
     uint32_t                                    maxComputeSharedMemorySize;
     uint32_t                                    maxComputeWorkGroupCount[3];
@@ -1352,14 +1352,14 @@
 } VkDeviceCreateInfo;
 
 typedef struct {
-    char                                        extName[VK_MAX_EXTENSION_NAME];
+    char                                        extensionName[VK_MAX_EXTENSION_NAME];
     uint32_t                                    specVersion;
 } VkExtensionProperties;
 
 typedef struct {
     char                                        layerName[VK_MAX_EXTENSION_NAME];
     uint32_t                                    specVersion;
-    uint32_t                                    implVersion;
+    uint32_t                                    implementationVersion;
     char                                        description[VK_MAX_DESCRIPTION];
 } VkLayerProperties;
 
@@ -1369,7 +1369,7 @@
     uint32_t                                    waitSemaphoreCount;
     const VkSemaphore*                          pWaitSemaphores;
     uint32_t                                    commandBufferCount;
-    const VkCmdBuffer*                          pCommandBuffers;
+    const VkCommandBuffer*                          pCommandBuffers;
     uint32_t                                    signalSemaphoreCount;
     const VkSemaphore*                          pSignalSemaphores;
 } VkSubmitInfo;
@@ -1379,7 +1379,7 @@
     const void*                                 pNext;
     VkDeviceSize                                allocationSize;
     uint32_t                                    memoryTypeIndex;
-} VkMemoryAllocInfo;
+} VkMemoryAllocateInfo;
 
 typedef struct {
     VkStructureType                             sType;
@@ -1413,7 +1413,7 @@
     VkDeviceSize                                resourceOffset;
     VkDeviceSize                                size;
     VkDeviceMemory                              mem;
-    VkDeviceSize                                memOffset;
+    VkDeviceSize                                memoryOffset;
     VkSparseMemoryBindFlags                     flags;
 } VkSparseMemoryBind;
 
@@ -1446,7 +1446,7 @@
     VkOffset3D                                  offset;
     VkExtent3D                                  extent;
     VkDeviceMemory                              mem;
-    VkDeviceSize                                memOffset;
+    VkDeviceSize                                memoryOffset;
     VkSparseMemoryBindFlags                     flags;
 } VkSparseImageMemoryBind;
 
@@ -1554,9 +1554,9 @@
 typedef struct {
     VkImageAspectFlags                          aspectMask;
     uint32_t                                    baseMipLevel;
-    uint32_t                                    numLevels;
+    uint32_t                                    levelCount;
     uint32_t                                    baseArrayLayer;
-    uint32_t                                    numLayers;
+    uint32_t                                    layerCount;
 } VkImageSubresourceRange;
 
 typedef struct {
@@ -1702,13 +1702,13 @@
     float                                       depthBiasClamp;
     float                                       depthBiasSlopeFactor;
     float                                       lineWidth;
-} VkPipelineRasterStateCreateInfo;
+} VkPipelineRasterizationStateCreateInfo;
 
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
     VkPipelineMultisampleStateCreateFlags       flags;
-    uint32_t                                    rasterSamples;
+    uint32_t                                    rasterizationSamples;
     VkBool32                                    sampleShadingEnable;
     float                                       minSampleShading;
     const VkSampleMask*                         pSampleMask;
@@ -1744,10 +1744,10 @@
 typedef struct {
     VkBool32                                    blendEnable;
     VkBlend                                     srcBlendColor;
-    VkBlend                                     destBlendColor;
+    VkBlend                                     dstBlendColor;
     VkBlendOp                                   blendOpColor;
     VkBlend                                     srcBlendAlpha;
-    VkBlend                                     destBlendAlpha;
+    VkBlend                                     dstBlendAlpha;
     VkBlendOp                                   blendOpAlpha;
     VkChannelFlags                              channelWriteMask;
 } VkPipelineColorBlendAttachmentState;
@@ -1781,7 +1781,7 @@
     const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
     const VkPipelineTessellationStateCreateInfo* pTessellationState;
     const VkPipelineViewportStateCreateInfo*    pViewportState;
-    const VkPipelineRasterStateCreateInfo*      pRasterState;
+    const VkPipelineRasterizationStateCreateInfo*      pRasterizationState;
     const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
     const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
     const VkPipelineColorBlendStateCreateInfo*  pColorBlendState;
@@ -1874,7 +1874,7 @@
     VkDescriptorPool                            descriptorPool;
     uint32_t                                    setLayoutCount;
     const VkDescriptorSetLayout*                pSetLayouts;
-} VkDescriptorSetAllocInfo;
+} VkDescriptorSetAllocateInfo;
 
 typedef struct {
     VkSampler                                   sampler;
@@ -1891,9 +1891,9 @@
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    VkDescriptorSet                             destSet;
-    uint32_t                                    destBinding;
-    uint32_t                                    destArrayElement;
+    VkDescriptorSet                             dstSet;
+    uint32_t                                    dstBinding;
+    uint32_t                                    dstArrayElement;
     uint32_t                                    descriptorCount;
     VkDescriptorType                            descriptorType;
     const VkDescriptorImageInfo*                pImageInfo;
@@ -1907,9 +1907,9 @@
     VkDescriptorSet                             srcSet;
     uint32_t                                    srcBinding;
     uint32_t                                    srcArrayElement;
-    VkDescriptorSet                             destSet;
-    uint32_t                                    destBinding;
-    uint32_t                                    destArrayElement;
+    VkDescriptorSet                             dstSet;
+    uint32_t                                    dstBinding;
+    uint32_t                                    dstArrayElement;
     uint32_t                                    descriptorCount;
 } VkCopyDescriptorSet;
 
@@ -1957,9 +1957,9 @@
 
 typedef struct {
     uint32_t                                    srcSubpass;
-    uint32_t                                    destSubpass;
+    uint32_t                                    dstSubpass;
     VkPipelineStageFlags                        srcStageMask;
-    VkPipelineStageFlags                        destStageMask;
+    VkPipelineStageFlags                        dstStageMask;
     VkMemoryOutputFlags                         outputMask;
     VkMemoryInputFlags                          inputMask;
     VkDependencyFlags                           dependencyFlags;
@@ -1980,30 +1980,30 @@
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    VkCmdPoolCreateFlags                        flags;
+    VkCommandPoolCreateFlags                        flags;
     uint32_t                                    queueFamilyIndex;
-} VkCmdPoolCreateInfo;
+} VkCommandPoolCreateInfo;
 
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    VkCmdPool                                   cmdPool;
-    VkCmdBufferLevel                            level;
+    VkCommandPool                                   commandPool;
+    VkCommandBufferLevel                            level;
     uint32_t                                    bufferCount;
-} VkCmdBufferAllocInfo;
+} VkCommandBufferAllocateInfo;
 
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    VkCmdBufferUsageFlags                       flags;
+    VkCommandBufferUsageFlags                       flags;
     VkRenderPass                                renderPass;
     uint32_t                                    subpass;
     VkFramebuffer                               framebuffer;
-} VkCmdBufferBeginInfo;
+} VkCommandBufferBeginInfo;
 
 typedef struct {
     VkDeviceSize                                srcOffset;
-    VkDeviceSize                                destOffset;
+    VkDeviceSize                                dstOffset;
     VkDeviceSize                                size;
 } VkBufferCopy;
 
@@ -2011,14 +2011,14 @@
     VkImageAspectFlags                          aspect;
     uint32_t                                    mipLevel;
     uint32_t                                    baseArrayLayer;
-    uint32_t                                    numLayers;
+    uint32_t                                    layerCount;
 } VkImageSubresourceCopy;
 
 typedef struct {
     VkImageSubresourceCopy                      srcSubresource;
     VkOffset3D                                  srcOffset;
-    VkImageSubresourceCopy                      destSubresource;
-    VkOffset3D                                  destOffset;
+    VkImageSubresourceCopy                      dstSubresource;
+    VkOffset3D                                  dstOffset;
     VkExtent3D                                  extent;
 } VkImageCopy;
 
@@ -2026,8 +2026,8 @@
     VkImageSubresourceCopy                      srcSubresource;
     VkOffset3D                                  srcOffset;
     VkExtent3D                                  srcExtent;
-    VkImageSubresourceCopy                      destSubresource;
-    VkOffset3D                                  destOffset;
+    VkImageSubresourceCopy                      dstSubresource;
+    VkOffset3D                                  dstOffset;
     VkExtent3D                                  destExtent;
 } VkImageBlit;
 
@@ -2065,14 +2065,14 @@
 typedef struct {
     VkRect2D                                    rect;
     uint32_t                                    baseArrayLayer;
-    uint32_t                                    numLayers;
+    uint32_t                                    layerCount;
 } VkClearRect;
 
 typedef struct {
     VkImageSubresourceCopy                      srcSubresource;
     VkOffset3D                                  srcOffset;
-    VkImageSubresourceCopy                      destSubresource;
-    VkOffset3D                                  destOffset;
+    VkImageSubresourceCopy                      dstSubresource;
+    VkOffset3D                                  dstOffset;
     VkExtent3D                                  extent;
 } VkImageResolve;
 
@@ -2092,7 +2092,7 @@
     VkMemoryOutputFlags                         outputMask;
     VkMemoryInputFlags                          inputMask;
     uint32_t                                    srcQueueFamilyIndex;
-    uint32_t                                    destQueueFamilyIndex;
+    uint32_t                                    dstQueueFamilyIndex;
     VkBuffer                                    buffer;
     VkDeviceSize                                offset;
     VkDeviceSize                                size;
@@ -2127,7 +2127,7 @@
     VkImageLayout                               oldLayout;
     VkImageLayout                               newLayout;
     uint32_t                                    srcQueueFamilyIndex;
-    uint32_t                                    destQueueFamilyIndex;
+    uint32_t                                    dstQueueFamilyIndex;
     VkImage                                     image;
     VkImageSubresourceRange                     subresourceRange;
 } VkImageMemoryBarrier;
@@ -2140,8 +2140,8 @@
 } VkMemoryBarrier;
 
 
-typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance);
-typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
+typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
 typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
 typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
@@ -2151,8 +2151,8 @@
 typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
 typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
 typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
-typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice);
-typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
+typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
 typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
 typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
@@ -2161,134 +2161,134 @@
 typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
 typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
 typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
-typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem);
-typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
+typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
 typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
-typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
-typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
+typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
 typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
-typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset);
+typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset);
 typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
 typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
 typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
 typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
 typedef VkResult (VKAPI *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
-typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence);
-typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
 typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
 typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
-typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore);
-typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent);
-typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
+typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
+typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
 typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
 typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
-typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool);
-typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
+typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
-typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer);
-typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView);
-typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage);
-typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
+typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
+typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
+typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
 typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
-typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView);
-typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShaderModule);
-typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader);
-typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
-typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
+typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
+typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader);
+typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
+typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
-typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
-typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
-typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
-typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
-typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler);
-typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
-typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
-typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
+typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
+typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
+typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
+typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
-typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
+typedef VkResult (VKAPI *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
 typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
 typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
-typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
-typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass);
-typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
+typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
 typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
-typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool);
-typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
-typedef VkResult (VKAPI *PFN_vkAllocCommandBuffers)(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
-typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers);
-typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
-typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
-typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
-typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
-typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
-typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
-typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth);
-typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
-typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConstants[4]);
-typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
-typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
-typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
-typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
-typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
-typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
-typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
-typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
-typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
-typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
-typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
-typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
-typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
-typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
-typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
-typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
-typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
-typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
-typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
-typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data);
-typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
-typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
-typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
-typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
-typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
-typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
-typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
-typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
-typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
-typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
-typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkQueryResultFlags flags);
-typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values);
-typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
-typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents);
-typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer);
-typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers);
+typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
+typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
+typedef VkResult (VKAPI *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
+typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
+typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
+typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
+typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);
+typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
+typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
+typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
+typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
+typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
+typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
+typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
+typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
+typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+typedef void (VKAPI *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+typedef void (VKAPI *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
+typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
+typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData);
+typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
+typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
+typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
+typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot);
+typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
+typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values);
+typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkRenderPassContents contents);
+typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
+typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers);
 
 #ifdef VK_PROTOTYPES
 VkResult VKAPI vkCreateInstance(
     const VkInstanceCreateInfo*                 pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkInstance*                                 pInstance);
 
 void VKAPI vkDestroyInstance(
     VkInstance                                  instance,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkEnumeratePhysicalDevices(
     VkInstance                                  instance,
@@ -2337,12 +2337,12 @@
 VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice                            physicalDevice,
     const VkDeviceCreateInfo*                   pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkDevice*                                   pDevice);
 
 void VKAPI vkDestroyDevice(
     VkDevice                                    device,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkEnumerateInstanceExtensionProperties(
     const char*                                 pLayerName,
@@ -2382,16 +2382,16 @@
 VkResult VKAPI vkDeviceWaitIdle(
     VkDevice                                    device);
 
-VkResult VKAPI vkAllocMemory(
+VkResult VKAPI vkAllocateMemory(
     VkDevice                                    device,
-    const VkMemoryAllocInfo*                    pAllocInfo,
-    const VkAllocCallbacks*                     pAllocator,
-    VkDeviceMemory*                             pMem);
+    const VkMemoryAllocateInfo*                    pAllocateInfo,
+    const VkAllocationCallbacks*                     pAllocator,
+    VkDeviceMemory*                             pMemory);
 
 void VKAPI vkFreeMemory(
     VkDevice                                    device,
     VkDeviceMemory                              mem,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkMapMemory(
     VkDevice                                    device,
@@ -2407,13 +2407,13 @@
 
 VkResult VKAPI vkFlushMappedMemoryRanges(
     VkDevice                                    device,
-    uint32_t                                    memRangeCount,
-    const VkMappedMemoryRange*                  pMemRanges);
+    uint32_t                                    memoryRangeCount,
+    const VkMappedMemoryRange*                  pMemoryRanges);
 
 VkResult VKAPI vkInvalidateMappedMemoryRanges(
     VkDevice                                    device,
-    uint32_t                                    memRangeCount,
-    const VkMappedMemoryRange*                  pMemRanges);
+    uint32_t                                    memoryRangeCount,
+    const VkMappedMemoryRange*                  pMemoryRanges);
 
 void VKAPI vkGetDeviceMemoryCommitment(
     VkDevice                                    device,
@@ -2424,13 +2424,13 @@
     VkDevice                                    device,
     VkBuffer                                    buffer,
     VkDeviceMemory                              mem,
-    VkDeviceSize                                memOffset);
+    VkDeviceSize                                memoryOffset);
 
 VkResult VKAPI vkBindImageMemory(
     VkDevice                                    device,
     VkImage                                     image,
     VkDeviceMemory                              mem,
-    VkDeviceSize                                memOffset);
+    VkDeviceSize                                memoryOffset);
 
 void VKAPI vkGetBufferMemoryRequirements(
     VkDevice                                    device,
@@ -2467,13 +2467,13 @@
 VkResult VKAPI vkCreateFence(
     VkDevice                                    device,
     const VkFenceCreateInfo*                    pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkFence*                                    pFence);
 
 void VKAPI vkDestroyFence(
     VkDevice                                    device,
     VkFence                                     fence,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkResetFences(
     VkDevice                                    device,
@@ -2494,24 +2494,24 @@
 VkResult VKAPI vkCreateSemaphore(
     VkDevice                                    device,
     const VkSemaphoreCreateInfo*                pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkSemaphore*                                pSemaphore);
 
 void VKAPI vkDestroySemaphore(
     VkDevice                                    device,
     VkSemaphore                                 semaphore,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateEvent(
     VkDevice                                    device,
     const VkEventCreateInfo*                    pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkEvent*                                    pEvent);
 
 void VKAPI vkDestroyEvent(
     VkDevice                                    device,
     VkEvent                                     event,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkGetEventStatus(
     VkDevice                                    device,
@@ -2528,13 +2528,13 @@
 VkResult VKAPI vkCreateQueryPool(
     VkDevice                                    device,
     const VkQueryPoolCreateInfo*                pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkQueryPool*                                pQueryPool);
 
 void VKAPI vkDestroyQueryPool(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkGetQueryPoolResults(
     VkDevice                                    device,
@@ -2549,35 +2549,35 @@
 VkResult VKAPI vkCreateBuffer(
     VkDevice                                    device,
     const VkBufferCreateInfo*                   pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkBuffer*                                   pBuffer);
 
 void VKAPI vkDestroyBuffer(
     VkDevice                                    device,
     VkBuffer                                    buffer,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateBufferView(
     VkDevice                                    device,
     const VkBufferViewCreateInfo*               pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkBufferView*                               pView);
 
 void VKAPI vkDestroyBufferView(
     VkDevice                                    device,
     VkBufferView                                bufferView,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateImage(
     VkDevice                                    device,
     const VkImageCreateInfo*                    pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkImage*                                    pImage);
 
 void VKAPI vkDestroyImage(
     VkDevice                                    device,
     VkImage                                     image,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 void VKAPI vkGetImageSubresourceLayout(
     VkDevice                                    device,
@@ -2588,46 +2588,46 @@
 VkResult VKAPI vkCreateImageView(
     VkDevice                                    device,
     const VkImageViewCreateInfo*                pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkImageView*                                pView);
 
 void VKAPI vkDestroyImageView(
     VkDevice                                    device,
     VkImageView                                 imageView,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateShaderModule(
     VkDevice                                    device,
     const VkShaderModuleCreateInfo*             pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkShaderModule*                             pShaderModule);
 
 void VKAPI vkDestroyShaderModule(
     VkDevice                                    device,
     VkShaderModule                              shaderModule,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateShader(
     VkDevice                                    device,
     const VkShaderCreateInfo*                   pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkShader*                                   pShader);
 
 void VKAPI vkDestroyShader(
     VkDevice                                    device,
     VkShader                                    shader,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreatePipelineCache(
     VkDevice                                    device,
     const VkPipelineCacheCreateInfo*            pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkPipelineCache*                            pPipelineCache);
 
 void VKAPI vkDestroyPipelineCache(
     VkDevice                                    device,
     VkPipelineCache                             pipelineCache,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkGetPipelineCacheData(
     VkDevice                                    device,
@@ -2637,7 +2637,7 @@
 
 VkResult VKAPI vkMergePipelineCaches(
     VkDevice                                    device,
-    VkPipelineCache                             destCache,
+    VkPipelineCache                             dstCache,
     uint32_t                                    srcCacheCount,
     const VkPipelineCache*                      pSrcCaches);
 
@@ -2646,7 +2646,7 @@
     VkPipelineCache                             pipelineCache,
     uint32_t                                    createInfoCount,
     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkPipeline*                                 pPipelines);
 
 VkResult VKAPI vkCreateComputePipelines(
@@ -2654,66 +2654,66 @@
     VkPipelineCache                             pipelineCache,
     uint32_t                                    createInfoCount,
     const VkComputePipelineCreateInfo*          pCreateInfos,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkPipeline*                                 pPipelines);
 
 void VKAPI vkDestroyPipeline(
     VkDevice                                    device,
     VkPipeline                                  pipeline,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreatePipelineLayout(
     VkDevice                                    device,
     const VkPipelineLayoutCreateInfo*           pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkPipelineLayout*                           pPipelineLayout);
 
 void VKAPI vkDestroyPipelineLayout(
     VkDevice                                    device,
     VkPipelineLayout                            pipelineLayout,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateSampler(
     VkDevice                                    device,
     const VkSamplerCreateInfo*                  pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkSampler*                                  pSampler);
 
 void VKAPI vkDestroySampler(
     VkDevice                                    device,
     VkSampler                                   sampler,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateDescriptorSetLayout(
     VkDevice                                    device,
     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkDescriptorSetLayout*                      pSetLayout);
 
 void VKAPI vkDestroyDescriptorSetLayout(
     VkDevice                                    device,
     VkDescriptorSetLayout                       descriptorSetLayout,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateDescriptorPool(
     VkDevice                                    device,
     const VkDescriptorPoolCreateInfo*           pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkDescriptorPool*                           pDescriptorPool);
 
 void VKAPI vkDestroyDescriptorPool(
     VkDevice                                    device,
     VkDescriptorPool                            descriptorPool,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkResetDescriptorPool(
     VkDevice                                    device,
     VkDescriptorPool                            descriptorPool,
     VkDescriptorPoolResetFlags                  flags);
 
-VkResult VKAPI vkAllocDescriptorSets(
+VkResult VKAPI vkAllocateDescriptorSets(
     VkDevice                                    device,
-    const VkDescriptorSetAllocInfo*             pAllocInfo,
+    const VkDescriptorSetAllocateInfo*             pAllocateInfo,
     VkDescriptorSet*                            pDescriptorSets);
 
 VkResult VKAPI vkFreeDescriptorSets(
@@ -2732,24 +2732,24 @@
 VkResult VKAPI vkCreateFramebuffer(
     VkDevice                                    device,
     const VkFramebufferCreateInfo*              pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkFramebuffer*                              pFramebuffer);
 
 void VKAPI vkDestroyFramebuffer(
     VkDevice                                    device,
     VkFramebuffer                               framebuffer,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateRenderPass(
     VkDevice                                    device,
     const VkRenderPassCreateInfo*               pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkRenderPass*                               pRenderPass);
 
 void VKAPI vkDestroyRenderPass(
     VkDevice                                    device,
     VkRenderPass                                renderPass,
-    const VkAllocCallbacks*                     pAllocator);
+    const VkAllocationCallbacks*                     pAllocator);
 
 void VKAPI vkGetRenderAreaGranularity(
     VkDevice                                    device,
@@ -2758,93 +2758,93 @@
 
 VkResult VKAPI vkCreateCommandPool(
     VkDevice                                    device,
-    const VkCmdPoolCreateInfo*                  pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
-    VkCmdPool*                                  pCmdPool);
+    const VkCommandPoolCreateInfo*                  pCreateInfo,
+    const VkAllocationCallbacks*                     pAllocator,
+    VkCommandPool*                                  pCommandPool);
 
 void VKAPI vkDestroyCommandPool(
     VkDevice                                    device,
-    VkCmdPool                                   cmdPool,
-    const VkAllocCallbacks*                     pAllocator);
+    VkCommandPool                                   commandPool,
+    const VkAllocationCallbacks*                     pAllocator);
 
 VkResult VKAPI vkResetCommandPool(
     VkDevice                                    device,
-    VkCmdPool                                   cmdPool,
-    VkCmdPoolResetFlags                         flags);
+    VkCommandPool                                   commandPool,
+    VkCommandPoolResetFlags                         flags);
 
-VkResult VKAPI vkAllocCommandBuffers(
+VkResult VKAPI vkAllocateCommandBuffers(
     VkDevice                                    device,
-    const VkCmdBufferAllocInfo*                 pAllocInfo,
-    VkCmdBuffer*                                pCmdBuffers);
+    const VkCommandBufferAllocateInfo*                 pAllocateInfo,
+    VkCommandBuffer*                                pCommandBuffers);
 
 void VKAPI vkFreeCommandBuffers(
     VkDevice                                    device,
-    VkCmdPool                                   cmdPool,
+    VkCommandPool                                   commandPool,
     uint32_t                                    commandBufferCount,
-    const VkCmdBuffer*                          pCommandBuffers);
+    const VkCommandBuffer*                          pCommandBuffers);
 
 VkResult VKAPI vkBeginCommandBuffer(
-    VkCmdBuffer                                 cmdBuffer,
-    const VkCmdBufferBeginInfo*                 pBeginInfo);
+    VkCommandBuffer                                 commandBuffer,
+    const VkCommandBufferBeginInfo*                 pBeginInfo);
 
 VkResult VKAPI vkEndCommandBuffer(
-    VkCmdBuffer                                 cmdBuffer);
+    VkCommandBuffer                                 commandBuffer);
 
 VkResult VKAPI vkResetCommandBuffer(
-    VkCmdBuffer                                 cmdBuffer,
-    VkCmdBufferResetFlags                       flags);
+    VkCommandBuffer                                 commandBuffer,
+    VkCommandBufferResetFlags                       flags);
 
 void VKAPI vkCmdBindPipeline(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkPipelineBindPoint                         pipelineBindPoint,
     VkPipeline                                  pipeline);
 
 void VKAPI vkCmdSetViewport(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     uint32_t                                    viewportCount,
     const VkViewport*                           pViewports);
 
 void VKAPI vkCmdSetScissor(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     uint32_t                                    scissorCount,
     const VkRect2D*                             pScissors);
 
 void VKAPI vkCmdSetLineWidth(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     float                                       lineWidth);
 
 void VKAPI vkCmdSetDepthBias(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     float                                       depthBiasConstantFactor,
     float                                       depthBiasClamp,
     float                                       depthBiasSlopeFactor);
 
 void VKAPI vkCmdSetBlendConstants(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     const float                                 blendConstants[4]);
 
 void VKAPI vkCmdSetDepthBounds(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     float                                       minDepthBounds,
     float                                       maxDepthBounds);
 
 void VKAPI vkCmdSetStencilCompareMask(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkStencilFaceFlags                          faceMask,
     uint32_t                                    stencilCompareMask);
 
 void VKAPI vkCmdSetStencilWriteMask(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkStencilFaceFlags                          faceMask,
     uint32_t                                    stencilWriteMask);
 
 void VKAPI vkCmdSetStencilReference(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkStencilFaceFlags                          faceMask,
     uint32_t                                    stencilReference);
 
 void VKAPI vkCmdBindDescriptorSets(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkPipelineBindPoint                         pipelineBindPoint,
     VkPipelineLayout                            layout,
     uint32_t                                    firstSet,
@@ -2854,27 +2854,27 @@
     const uint32_t*                             pDynamicOffsets);
 
 void VKAPI vkCmdBindIndexBuffer(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkBuffer                                    buffer,
     VkDeviceSize                                offset,
     VkIndexType                                 indexType);
 
 void VKAPI vkCmdBindVertexBuffers(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     uint32_t                                    startBinding,
     uint32_t                                    bindingCount,
     const VkBuffer*                             pBuffers,
     const VkDeviceSize*                         pOffsets);
 
 void VKAPI vkCmdDraw(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     uint32_t                                    vertexCount,
     uint32_t                                    instanceCount,
     uint32_t                                    firstVertex,
     uint32_t                                    firstInstance);
 
 void VKAPI vkCmdDrawIndexed(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     uint32_t                                    indexCount,
     uint32_t                                    instanceCount,
     uint32_t                                    firstIndex,
@@ -2882,88 +2882,88 @@
     uint32_t                                    firstInstance);
 
 void VKAPI vkCmdDrawIndirect(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkBuffer                                    buffer,
     VkDeviceSize                                offset,
     uint32_t                                    drawCount,
     uint32_t                                    stride);
 
 void VKAPI vkCmdDrawIndexedIndirect(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkBuffer                                    buffer,
     VkDeviceSize                                offset,
     uint32_t                                    drawCount,
     uint32_t                                    stride);
 
 void VKAPI vkCmdDispatch(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     uint32_t                                    x,
     uint32_t                                    y,
     uint32_t                                    z);
 
 void VKAPI vkCmdDispatchIndirect(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkBuffer                                    buffer,
     VkDeviceSize                                offset);
 
 void VKAPI vkCmdCopyBuffer(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkBuffer                                    srcBuffer,
-    VkBuffer                                    destBuffer,
+    VkBuffer                                    dstBuffer,
     uint32_t                                    regionCount,
     const VkBufferCopy*                         pRegions);
 
 void VKAPI vkCmdCopyImage(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkImage                                     srcImage,
     VkImageLayout                               srcImageLayout,
-    VkImage                                     destImage,
-    VkImageLayout                               destImageLayout,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
     uint32_t                                    regionCount,
     const VkImageCopy*                          pRegions);
 
 void VKAPI vkCmdBlitImage(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkImage                                     srcImage,
     VkImageLayout                               srcImageLayout,
-    VkImage                                     destImage,
-    VkImageLayout                               destImageLayout,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
     uint32_t                                    regionCount,
     const VkImageBlit*                          pRegions,
     VkFilter                                    filter);
 
 void VKAPI vkCmdCopyBufferToImage(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkBuffer                                    srcBuffer,
-    VkImage                                     destImage,
-    VkImageLayout                               destImageLayout,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
     uint32_t                                    regionCount,
     const VkBufferImageCopy*                    pRegions);
 
 void VKAPI vkCmdCopyImageToBuffer(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkImage                                     srcImage,
     VkImageLayout                               srcImageLayout,
-    VkBuffer                                    destBuffer,
+    VkBuffer                                    dstBuffer,
     uint32_t                                    regionCount,
     const VkBufferImageCopy*                    pRegions);
 
 void VKAPI vkCmdUpdateBuffer(
-    VkCmdBuffer                                 cmdBuffer,
-    VkBuffer                                    destBuffer,
-    VkDeviceSize                                destOffset,
+    VkCommandBuffer                                 commandBuffer,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
     VkDeviceSize                                dataSize,
     const uint32_t*                             pData);
 
 void VKAPI vkCmdFillBuffer(
-    VkCmdBuffer                                 cmdBuffer,
-    VkBuffer                                    destBuffer,
-    VkDeviceSize                                destOffset,
+    VkCommandBuffer                                 commandBuffer,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
     VkDeviceSize                                size,
     uint32_t                                    data);
 
 void VKAPI vkCmdClearColorImage(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkImage                                     image,
     VkImageLayout                               imageLayout,
     const VkClearColorValue*                    pColor,
@@ -2971,7 +2971,7 @@
     const VkImageSubresourceRange*              pRanges);
 
 void VKAPI vkCmdClearDepthStencilImage(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkImage                                     image,
     VkImageLayout                               imageLayout,
     const VkClearDepthStencilValue*             pDepthStencil,
@@ -2979,83 +2979,83 @@
     const VkImageSubresourceRange*              pRanges);
 
 void VKAPI vkCmdClearAttachments(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     uint32_t                                    attachmentCount,
     const VkClearAttachment*                    pAttachments,
     uint32_t                                    rectCount,
     const VkClearRect*                          pRects);
 
 void VKAPI vkCmdResolveImage(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkImage                                     srcImage,
     VkImageLayout                               srcImageLayout,
-    VkImage                                     destImage,
-    VkImageLayout                               destImageLayout,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
     uint32_t                                    regionCount,
     const VkImageResolve*                       pRegions);
 
 void VKAPI vkCmdSetEvent(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkEvent                                     event,
     VkPipelineStageFlags                        stageMask);
 
 void VKAPI vkCmdResetEvent(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkEvent                                     event,
     VkPipelineStageFlags                        stageMask);
 
 void VKAPI vkCmdWaitEvents(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     uint32_t                                    eventCount,
     const VkEvent*                              pEvents,
     VkPipelineStageFlags                        srcStageMask,
-    VkPipelineStageFlags                        destStageMask,
-    uint32_t                                    memBarrierCount,
-    const void* const*                          ppMemBarriers);
+    VkPipelineStageFlags                        dstStageMask,
+    uint32_t                                    memoryBarrierCount,
+    const void* const*                          ppMemoryBarriers);
 
 void VKAPI vkCmdPipelineBarrier(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkPipelineStageFlags                        srcStageMask,
-    VkPipelineStageFlags                        destStageMask,
+    VkPipelineStageFlags                        dstStageMask,
     VkDependencyFlags                           dependencyFlags,
-    uint32_t                                    memBarrierCount,
-    const void* const*                          ppMemBarriers);
+    uint32_t                                    memoryBarrierCount,
+    const void* const*                          ppMemoryBarriers);
 
 void VKAPI vkCmdBeginQuery(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkQueryPool                                 queryPool,
     uint32_t                                    slot,
     VkQueryControlFlags                         flags);
 
 void VKAPI vkCmdEndQuery(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkQueryPool                                 queryPool,
     uint32_t                                    slot);
 
 void VKAPI vkCmdResetQueryPool(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkQueryPool                                 queryPool,
     uint32_t                                    startQuery,
     uint32_t                                    queryCount);
 
 void VKAPI vkCmdWriteTimestamp(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkPipelineStageFlagBits                     pipelineStage,
     VkQueryPool                                 queryPool,
     uint32_t                                    slot);
 
 void VKAPI vkCmdCopyQueryPoolResults(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkQueryPool                                 queryPool,
     uint32_t                                    startQuery,
     uint32_t                                    queryCount,
-    VkBuffer                                    destBuffer,
-    VkDeviceSize                                destOffset,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
     VkDeviceSize                                stride,
     VkQueryResultFlags                          flags);
 
 void VKAPI vkCmdPushConstants(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkPipelineLayout                            layout,
     VkShaderStageFlags                          stageFlags,
     uint32_t                                    offset,
@@ -3063,21 +3063,21 @@
     const void*                                 values);
 
 void VKAPI vkCmdBeginRenderPass(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     const VkRenderPassBeginInfo*                pRenderPassBegin,
     VkRenderPassContents                        contents);
 
 void VKAPI vkCmdNextSubpass(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     VkRenderPassContents                        contents);
 
 void VKAPI vkCmdEndRenderPass(
-    VkCmdBuffer                                 cmdBuffer);
+    VkCommandBuffer                                 commandBuffer);
 
 void VKAPI vkCmdExecuteCommands(
-    VkCmdBuffer                                 cmdBuffer,
-    uint32_t                                    cmdBuffersCount,
-    const VkCmdBuffer*                          pCmdBuffers);
+    VkCommandBuffer                                 commandBuffer,
+    uint32_t                                    commandBuffersCount,
+    const VkCommandBuffer*                          pCommandBuffers);
 #endif
 
 #ifdef __cplusplus
diff --git a/layers/README.md b/layers/README.md
index 4e53ed8..8ee47b9 100644
--- a/layers/README.md
+++ b/layers/README.md
@@ -10,7 +10,7 @@
 available layers and their properties. Layers can intercept Vulkan instance level entry points
 in which case they are called an Instance Layer.  Layers can intercept device entry  points
 in which case they are called a Device Layer. Instance level entry points are those with VkInstance
-or VkPhysicalDevice as first parameter.  Device level entry points are those with VkDevice, VkCmdBuffer,
+or VkPhysicalDevice as first parameter.  Device level entry points are those with VkDevice, VkCommandBuffer,
 or VkQueue as the first parameter. Layers that want to intercept both instance and device
 level entrypoints are called Global Layers. vkXXXXGetProcAddr is used internally by the Layers and
 Loader to initialize dispatch tables. Device Layers are activated at vkCreateDevice time. Instance
diff --git a/layers/apidump.h b/layers/apidump.h
index fb8dcf1..28eab02 100644
--- a/layers/apidump.h
+++ b/layers/apidump.h
@@ -37,7 +37,7 @@
     {
         "Generic",
         VK_API_VERSION,                 // specVersion
-        VK_MAKE_VERSION(0, 1, 0),       // implVersion
+        VK_MAKE_VERSION(0, 1, 0),       // implementationVersion
         "layer: APIDump",
     }
 };
@@ -47,7 +47,7 @@
     {
         "Generic",
         VK_API_VERSION,                 // specVersion
-        VK_MAKE_VERSION(0, 1, 0),       // implVersion
+        VK_MAKE_VERSION(0, 1, 0),       // implementationVersion
         "layer: APIDump",
     }
 };
diff --git a/layers/basic.cpp b/layers/basic.cpp
index f416d5a..a87ab59 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -34,7 +34,7 @@
     {
         "Basic",
         VK_API_VERSION,                 // specVersion
-        VK_MAKE_VERSION(0, 1, 0),       // implVersion
+        VK_MAKE_VERSION(0, 1, 0),       // implementationVersion
         "layer: Basic",
     }
 };
@@ -95,7 +95,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI basic_CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI basic_CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
 {
     printf("At start of wrapped vkCreateDevice() call w/ gpu: %p\n", (void*)gpu);
     VkResult result = device_dispatch_table(*pDevice)->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
@@ -104,7 +104,7 @@
 }
 
 /* hook DestroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI basic_DestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI basic_DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(device);
     device_dispatch_table(device)->DestroyDevice(device, pAllocator);
@@ -112,7 +112,7 @@
 }
 
 /* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI basic_DestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI basic_DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(instance);
     instance_dispatch_table(instance)->DestroyInstance(instance, pAllocator);
diff --git a/layers/device_limits.cpp b/layers/device_limits.cpp
index 41b0b6f..89d5885 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -158,7 +158,7 @@
                                    pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
     VkLayerInstanceDispatchTable* pTable = my_data->instance_dispatch_table;
@@ -178,7 +178,7 @@
 }
 
 /* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(instance);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -317,20 +317,20 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     uint32_t                            viewportCount,
     const VkViewport*                   pViewports)
 {
     VkBool32 skipCall = VK_FALSE;
     /* TODO: Verify viewportCount < maxViewports from VkPhysicalDeviceLimits */
     if (VK_FALSE == skipCall) {
-        layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-        my_data->device_dispatch_table->CmdSetViewport(cmdBuffer, viewportCount, pViewports);
+        layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+        my_data->device_dispatch_table->CmdSetViewport(commandBuffer, viewportCount, pViewports);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     uint32_t                            scissorCount,
     const VkRect2D*                     pScissors)
 {
@@ -338,8 +338,8 @@
     /* TODO: Verify scissorCount < maxViewports from VkPhysicalDeviceLimits */
     /* TODO: viewportCount and scissorCount must match at draw time */
     if (VK_FALSE == skipCall) {
-        layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-        my_data->device_dispatch_table->CmdSetScissor(cmdBuffer, scissorCount, pScissors);
+        layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+        my_data->device_dispatch_table->CmdSetScissor(commandBuffer, scissorCount, pScissors);
     }
 }
 
@@ -387,7 +387,7 @@
     return skipCall;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
@@ -429,7 +429,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
 {
     // Free device lifetime allocations
     dispatch_key key = get_dispatch_key(device);
@@ -440,33 +440,33 @@
     layer_data_map.erase(key);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
 {
     // TODO : Verify that requested QueueFamilyIndex for this pool exists
-    VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
+    VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyCommandPool(device, cmdPool, pAllocator);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyCommandPool(device, commandPool, pAllocator);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags)
+VK_LAYER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 {
-    VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->ResetCommandPool(device, cmdPool, flags);
+    VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->ResetCommandPool(device, commandPool, flags);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pCreateInfo, VkCommandBuffer* pCommandBuffer)
 {
-    VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
+    VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers)
+VK_LAYER_EXPORT void VKAPI vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t count, const VkCommandBuffer* pCommandBuffers)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->FreeCommandBuffers(device, commandPool, count, pCommandBuffers);
 }
 
 VK_LAYER_EXPORT void VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
@@ -490,7 +490,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
     VkDevice                 device,
     const VkImageCreateInfo *pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkImage                 *pImage)
 {
     VkBool32                skipCall       = VK_FALSE;
@@ -543,63 +543,63 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(
-    VkCmdBuffer cmdBuffer,
-    VkBuffer destBuffer,
-    VkDeviceSize destOffset,
+    VkCommandBuffer commandBuffer,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
     VkDeviceSize dataSize,
     const uint32_t* pData)
 {
-    layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
 
-    // destOffset is the byte offset into the buffer to start updating and must be a multiple of 4.
-    if (destOffset & 3) {
-        layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    // dstOffset is the byte offset into the buffer to start updating and must be a multiple of 4.
+    if (dstOffset & 3) {
+        layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
         if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL",
-        "vkCmdUpdateBuffer parameter, VkDeviceSize destOffset, is not a multiple of 4")) {
+        "vkCmdUpdateBuffer parameter, VkDeviceSize dstOffset, is not a multiple of 4")) {
             return;
         }
     }
 
     // dataSize is the number of bytes to update, which must be a multiple of 4.
     if (dataSize & 3) {
-        layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+        layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
         if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL",
         "vkCmdUpdateBuffer parameter, VkDeviceSize dataSize, is not a multiple of 4")) {
             return;
         }
     }
 
-    dev_data->device_dispatch_table->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+    dev_data->device_dispatch_table->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
-    VkCmdBuffer cmdBuffer,
-    VkBuffer destBuffer,
-    VkDeviceSize destOffset,
+    VkCommandBuffer commandBuffer,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
     VkDeviceSize size,
     uint32_t data)
 {
-    layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
 
-    // destOffset is the byte offset into the buffer to start filling and must be a multiple of 4.
-    if (destOffset & 3) {
-        layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    // dstOffset is the byte offset into the buffer to start filling and must be a multiple of 4.
+    if (dstOffset & 3) {
+        layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
         if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL",
-        "vkCmdFillBuffer parameter, VkDeviceSize destOffset, is not a multiple of 4")) {
+        "vkCmdFillBuffer parameter, VkDeviceSize dstOffset, is not a multiple of 4")) {
             return;
         }
     }
 
     // size is the number of bytes to fill, which must be a multiple of 4.
     if (size & 3) {
-        layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+        layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
         if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL",
         "vkCmdFillBuffer parameter, VkDeviceSize size, is not a multiple of 4")) {
             return;
         }
     }
 
-    dev_data->device_dispatch_table->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+    dev_data->device_dispatch_table->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
@@ -656,8 +656,8 @@
         return (PFN_vkVoidFunction) vkDestroyCommandPool;
     if (!strcmp(funcName, "ResetCommandPool"))
         return (PFN_vkVoidFunction) vkResetCommandPool;
-    if (!strcmp(funcName, "vkAllocCommandBuffers"))
-        return (PFN_vkVoidFunction) vkAllocCommandBuffers;
+    if (!strcmp(funcName, "vkAllocateCommandBuffers"))
+        return (PFN_vkVoidFunction) vkAllocateCommandBuffers;
     if (!strcmp(funcName, "vkFreeCommandBuffers"))
         return (PFN_vkVoidFunction) vkFreeCommandBuffers;
     if (!strcmp(funcName, "vkCmdUpdateBuffer"))
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index cf73369..d170830 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -75,7 +75,7 @@
     unordered_map<VkPipelineLayout, PIPELINE_LAYOUT_NODE> pipelineLayoutMap;
     unordered_map<VkShader, VkShaderStageFlagBits> shaderStageMap;
     // Map for layout chains
-    unordered_map<void*, GLOBAL_CB_NODE*> cmdBufferMap;
+    unordered_map<void*, GLOBAL_CB_NODE*> commandBufferMap;
     unordered_map<VkRenderPass, VkRenderPassCreateInfo*> renderPassMap;
     unordered_map<VkFramebuffer, VkFramebufferCreateInfo*> frameBufferMap;
 
@@ -226,11 +226,11 @@
 
 static uint64_t g_drawCount[NUM_DRAW_TYPES] = {0, 0, 0, 0};
 
-// TODO : Should be tracking lastBound per cmdBuffer and when draws occur, report based on that cmd buffer lastBound
+// TODO : Should be tracking lastBound per commandBuffer and when draws occur, report based on that cmd buffer lastBound
 //   Then need to synchronize the accesses based on cmd buffer so that if I'm reading state on one cmd buffer, updates
 //   to that same cmd buffer by separate thread are not changing state from underneath us
 // Track the last cmd buffer touched by this thread
-static VkCmdBuffer    g_lastCmdBuffer[MAX_TID] = {NULL};
+static VkCommandBuffer    g_lastCommandBuffer[MAX_TID] = {NULL};
 // Track the last group of CBs touched for displaying to dot file
 static GLOBAL_CB_NODE* g_pLastTouchedCB[NUM_COMMAND_BUFFERS_TO_DISPLAY] = {NULL};
 static uint32_t        g_lastTouchedCBIndex = 0;
@@ -239,11 +239,11 @@
 static PIPELINE_NODE*  g_lastBoundPipeline = NULL;
 #define MAX_BINDING 0xFFFFFFFF // Default vtxBinding value in CB Node to identify if no vtxBinding set
 // prototype
-static GLOBAL_CB_NODE* getCBNode(layer_data*, const VkCmdBuffer);
-// Update global ptrs to reflect that specified cmdBuffer has been used
+static GLOBAL_CB_NODE* getCBNode(layer_data*, const VkCommandBuffer);
+// Update global ptrs to reflect that specified commandBuffer has been used
 static void updateCBTracking(GLOBAL_CB_NODE* pCB)
 {
-    g_lastCmdBuffer[getTIDIndex()] = pCB->cmdBuffer;
+    g_lastCommandBuffer[getTIDIndex()] = pCB->commandBuffer;
     loader_platform_thread_lock_mutex(&globalLock);
     g_lastGlobalCB = pCB;
     // TODO : This is a dumb algorithm. Need smart LRU that drops off oldest
@@ -274,7 +274,7 @@
         if ((pNode->status & status_mask) != status_flag) {
             // TODO : How to pass dispatchable objects as srcObject? Here src obj should be cmd buffer
             return log_msg(my_data->report_data, msg_flags, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, error_code, "DS",
-                    "CB object %#" PRIxLEAST64 ": %s", reinterpret_cast<uint64_t>(pNode->cmdBuffer), fail_msg);
+                    "CB object %#" PRIxLEAST64 ": %s", reinterpret_cast<uint64_t>(pNode->commandBuffer), fail_msg);
         }
     }
     return VK_FALSE;
@@ -518,9 +518,9 @@
         memcpy((void*)&pPipeline->vpStateCI, pCreateInfo->pViewportState, sizeof(VkPipelineViewportStateCreateInfo));
         pPipeline->graphicsPipelineCI.pViewportState = &pPipeline->vpStateCI;
     }
-    if (pCreateInfo->pRasterState != NULL) {
-        memcpy((void*)&pPipeline->rsStateCI, pCreateInfo->pRasterState, sizeof(VkPipelineRasterStateCreateInfo));
-        pPipeline->graphicsPipelineCI.pRasterState = &pPipeline->rsStateCI;
+    if (pCreateInfo->pRasterizationState != NULL) {
+        memcpy((void*)&pPipeline->rsStateCI, pCreateInfo->pRasterizationState, sizeof(VkPipelineRasterizationStateCreateInfo));
+        pPipeline->graphicsPipelineCI.pRasterizationState = &pPipeline->rsStateCI;
     }
     if (pCreateInfo->pMultisampleState != NULL) {
         memcpy((void*)&pPipeline->msStateCI, pCreateInfo->pMultisampleState, sizeof(VkPipelineMultisampleStateCreateInfo));
@@ -584,7 +584,7 @@
 {
     PIPELINE_NODE* pPipe = my_data->pipelineMap[pipeline];
     if (VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO == pPipe->msStateCI.sType) {
-        return pPipe->msStateCI.rasterSamples;
+        return pPipe->msStateCI.rasterizationSamples;
     }
     return 1;
 }
@@ -1018,7 +1018,7 @@
     // Validate Write updates
     uint32_t i = 0;
     for (i=0; i < descriptorWriteCount; i++) {
-        VkDescriptorSet ds = pWDS[i].destSet;
+        VkDescriptorSet ds = pWDS[i].dstSet;
         SET_NODE* pSet = my_data->setMap[ds];
         GENERIC_HEADER* pUpdate = (GENERIC_HEADER*) &pWDS[i];
         pLayout = pSet->pLayout;
@@ -1027,14 +1027,14 @@
             break;
         }
         uint32_t binding = 0, endIndex = 0;
-        binding = pWDS[i].destBinding;
+        binding = pWDS[i].dstBinding;
         // Make sure that layout being updated has the binding being updated
         if (pLayout->createInfo.bindingCount < binding) {
             skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
                     "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, binding, string_VkStructureType(pUpdate->sType));
         } else {
             // Next verify that update falls within size of given binding
-            endIndex = getUpdateEndIndex(my_data, device, pLayout, binding, pWDS[i].destArrayElement, pUpdate);
+            endIndex = getUpdateEndIndex(my_data, device, pLayout, binding, pWDS[i].dstArrayElement, pUpdate);
             if (getBindingEndIndex(pLayout, binding) < endIndex) {
                 pLayoutCI = &pLayout->createInfo;
                 string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS}    ");
@@ -1042,7 +1042,7 @@
                         "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VkStructureType(pUpdate->sType), binding, DSstr.c_str());
             } else { // TODO : should we skip update on a type mismatch or force it?
                 uint32_t startIndex;
-                startIndex = getUpdateStartIndex(my_data, device, pLayout, binding, pWDS[i].destArrayElement, pUpdate);
+                startIndex = getUpdateStartIndex(my_data, device, pLayout, binding, pWDS[i].dstArrayElement, pUpdate);
                 // Layout bindings match w/ update, now verify that update type & stageFlags are the same for entire update
                 if ((skipCall = validateUpdateConsistency(my_data, device, pLayout, pUpdate, startIndex, endIndex)) == VK_FALSE) {
                     // The update is within bounds and consistent, but need to make sure contents make sense as well
@@ -1076,7 +1076,7 @@
         uint32_t srcStartIndex = 0, srcEndIndex = 0, dstStartIndex = 0, dstEndIndex = 0;
         // For each copy make sure that update falls within given layout and that types match
         pSrcSet = my_data->setMap[pCDS[i].srcSet];
-        pDstSet = my_data->setMap[pCDS[i].destSet];
+        pDstSet = my_data->setMap[pCDS[i].dstSet];
         pSrcLayout = pSrcSet->pLayout;
         pDstLayout = pDstSet->pLayout;
         // Validate that src binding is valid for src set layout
@@ -1084,27 +1084,27 @@
             skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
                 "Copy descriptor update %u has srcBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
                 i, pCDS[i].srcBinding, (uint64_t) pSrcLayout->layout, pSrcLayout->createInfo.bindingCount-1);
-        } else if (pDstLayout->createInfo.bindingCount < pCDS[i].destBinding) {
+        } else if (pDstLayout->createInfo.bindingCount < pCDS[i].dstBinding) {
             skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
-                "Copy descriptor update %u has destBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
-                i, pCDS[i].destBinding, (uint64_t) pDstLayout->layout, pDstLayout->createInfo.bindingCount-1);
+                "Copy descriptor update %u has dstBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
+                i, pCDS[i].dstBinding, (uint64_t) pDstLayout->layout, pDstLayout->createInfo.bindingCount-1);
         } else {
             // Proceed with validation. Bindings are ok, but make sure update is within bounds of given layout
             srcEndIndex = getUpdateEndIndex(my_data, device, pSrcLayout, pCDS[i].srcBinding, pCDS[i].srcArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
-            dstEndIndex = getUpdateEndIndex(my_data, device, pDstLayout, pCDS[i].destBinding, pCDS[i].destArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
+            dstEndIndex = getUpdateEndIndex(my_data, device, pDstLayout, pCDS[i].dstBinding, pCDS[i].dstArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
             if (getBindingEndIndex(pSrcLayout, pCDS[i].srcBinding) < srcEndIndex) {
                 pLayoutCI = &pSrcLayout->createInfo;
                 string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS}    ");
                 skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
                     "Copy descriptor src update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].srcBinding, DSstr.c_str());
-            } else if (getBindingEndIndex(pDstLayout, pCDS[i].destBinding) < dstEndIndex) {
+            } else if (getBindingEndIndex(pDstLayout, pCDS[i].dstBinding) < dstEndIndex) {
                 pLayoutCI = &pDstLayout->createInfo;
                 string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS}    ");
                 skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
-                    "Copy descriptor dest update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].destBinding, DSstr.c_str());
+                    "Copy descriptor dest update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].dstBinding, DSstr.c_str());
             } else {
                 srcStartIndex = getUpdateStartIndex(my_data, device, pSrcLayout, pCDS[i].srcBinding, pCDS[i].srcArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
-                dstStartIndex = getUpdateStartIndex(my_data, device, pDstLayout, pCDS[i].destBinding, pCDS[i].destArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
+                dstStartIndex = getUpdateStartIndex(my_data, device, pDstLayout, pCDS[i].dstBinding, pCDS[i].dstArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
                 for (uint32_t j=0; j<pCDS[i].descriptorCount; ++j) {
                     // For copy just make sure that the types match and then perform the update
                     if (pSrcLayout->descriptorTypes[srcStartIndex+j] != pDstLayout->descriptorTypes[dstStartIndex+j]) {
@@ -1131,7 +1131,7 @@
         LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pSetLayouts[i]);
         if (NULL == pLayout) {
             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 vkAllocDescriptorSets() call", (uint64_t) pSetLayouts[i]);
+                    "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocateDescriptorSets() call", (uint64_t) pSetLayouts[i]);
         } else {
             uint32_t typeIndex = 0, typeCount = 0;
             for (j=0; j<pLayout->createInfo.bindingCount; ++j) {
@@ -1282,26 +1282,26 @@
     }
 }
 // For given CB object, fetch associated CB Node from map
-static GLOBAL_CB_NODE* getCBNode(layer_data* my_data, const VkCmdBuffer cb)
+static GLOBAL_CB_NODE* getCBNode(layer_data* my_data, const VkCommandBuffer cb)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    if (my_data->cmdBufferMap.find(cb) == my_data->cmdBufferMap.end()) {
+    if (my_data->commandBufferMap.find(cb) == my_data->commandBufferMap.end()) {
         loader_platform_thread_unlock_mutex(&globalLock);
         // TODO : How to pass cb as srcObj here?
-        log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS",
-                "Attempt to use CmdBuffer %#" PRIxLEAST64 " that doesn't exist!", reinterpret_cast<uint64_t>(cb));
+        log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS",
+                "Attempt to use CommandBuffer %#" PRIxLEAST64 " that doesn't exist!", reinterpret_cast<uint64_t>(cb));
         return NULL;
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    return my_data->cmdBufferMap[cb];
+    return my_data->commandBufferMap[cb];
 }
 // Free all CB Nodes
 // NOTE : Calls to this function should be wrapped in mutex
-static void deleteCmdBuffers(layer_data* my_data)
+static void deleteCommandBuffers(layer_data* my_data)
 {
-    if (my_data->cmdBufferMap.size() <= 0)
+    if (my_data->commandBufferMap.size() <= 0)
         return;
-    for (auto ii=my_data->cmdBufferMap.begin(); ii!=my_data->cmdBufferMap.end(); ++ii) {
+    for (auto ii=my_data->commandBufferMap.begin(); ii!=my_data->commandBufferMap.end(); ++ii) {
         vector<CMD_NODE*> cmd_node_list = (*ii).second->pCmds;
         while (!cmd_node_list.empty()) {
             CMD_NODE* cmd_node = cmd_node_list.back();
@@ -1310,12 +1310,12 @@
         }
         delete (*ii).second;
     }
-    my_data->cmdBufferMap.clear();
+    my_data->commandBufferMap.clear();
 }
-static VkBool32 report_error_no_cb_begin(const layer_data* dev_data, const VkCmdBuffer cb, const char* caller_name)
+static VkBool32 report_error_no_cb_begin(const layer_data* dev_data, const VkCommandBuffer cb, const char* caller_name)
 {
     // TODO : How to pass cb as srcObj here?
-    return log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_BEGIN_CMD_BUFFER, "DS",
+    return log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_BEGIN_COMMAND_BUFFER, "DS",
             "You must call vkBeginCommandBuffer() before this call to %s", (void*)caller_name);
 }
 static VkBool32 addCmd(const layer_data* my_data, GLOBAL_CB_NODE* pCB, const CMD_TYPE cmd)
@@ -1331,11 +1331,11 @@
     } else {
         // TODO : How to pass cb as srcObj here?
         skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
-                "Out of memory while attempting to allocate new CMD_NODE for cmdBuffer %#" PRIxLEAST64, reinterpret_cast<uint64_t>(pCB->cmdBuffer));
+                "Out of memory while attempting to allocate new CMD_NODE for commandBuffer %#" PRIxLEAST64, reinterpret_cast<uint64_t>(pCB->commandBuffer));
     }
     return skipCall;
 }
-static void resetCB(layer_data* my_data, const VkCmdBuffer cb)
+static void resetCB(layer_data* my_data, const VkCommandBuffer cb)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(my_data, cb);
     if (pCB) {
@@ -1346,9 +1346,9 @@
         }
         pCB->pCmds.clear();
         // Reset CB state (need to save createInfo)
-        VkCmdBufferAllocInfo saveCBCI = pCB->createInfo;
+        VkCommandBufferAllocateInfo saveCBCI = pCB->createInfo;
         memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
-        pCB->cmdBuffer = cb;
+        pCB->commandBuffer = cb;
         pCB->createInfo = saveCBCI;
         pCB->lastVtxBinding = MAX_BINDING;
     }
@@ -1413,7 +1413,7 @@
     }
 }
 // Print the last bound Gfx Pipeline
-static VkBool32 printPipeline(layer_data* my_data, const VkCmdBuffer cb)
+static VkBool32 printPipeline(layer_data* my_data, const VkCommandBuffer cb)
 {
     VkBool32 skipCall = VK_FALSE;
     GLOBAL_CB_NODE* pCB = getCBNode(my_data, cb);
@@ -1429,7 +1429,7 @@
     return skipCall;
 }
 // Print details of DS config to stdout
-static VkBool32 printDSConfig(layer_data* my_data, const VkCmdBuffer cb)
+static VkBool32 printDSConfig(layer_data* my_data, const VkCommandBuffer cb)
 {
     VkBool32 skipCall = VK_FALSE;
     char ds_config_str[1024*256] = {0}; // TODO : Currently making this buffer HUGE w/o overrun protection.  Need to be smarter, start smaller, and grow as needed.
@@ -1478,7 +1478,7 @@
     return skipCall;
 }
 
-static void printCB(layer_data* my_data, const VkCmdBuffer cb)
+static void printCB(layer_data* my_data, const VkCommandBuffer cb)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(my_data, cb);
     if (pCB && pCB->pCmds.size() > 0) {
@@ -1495,7 +1495,7 @@
     }
 }
 
-static VkBool32 synchAndPrintDSConfig(layer_data* my_data, const VkCmdBuffer cb)
+static VkBool32 synchAndPrintDSConfig(layer_data* my_data, const VkCommandBuffer cb)
 {
     VkBool32 skipCall = VK_FALSE;
     if (!(my_data->report_data->active_flags & VK_DBG_REPORT_INFO_BIT)) {
@@ -1513,7 +1513,7 @@
     VkBool32 inside = VK_FALSE;
     if (pCB->activeRenderPass) {
         inside = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                         (uint64_t)pCB->cmdBuffer, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
+                         (uint64_t)pCB->commandBuffer, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
                          "%s: It is invalid to issue this call inside an active render pass (%#" PRIxLEAST64 ")",
                          apiName, (uint64_t) pCB->activeRenderPass);
     }
@@ -1527,7 +1527,7 @@
     VkBool32 outside = VK_FALSE;
     if (!pCB->activeRenderPass) {
         outside = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                          (uint64_t)pCB->cmdBuffer, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
+                          (uint64_t)pCB->commandBuffer, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
                           "%s: This call must be issued inside an active render pass.", apiName);
     }
     return outside;
@@ -1565,7 +1565,7 @@
     }
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
@@ -1585,7 +1585,7 @@
 }
 
 /* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(instance);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -1625,7 +1625,7 @@
     }
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
     VkResult result = dev_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
@@ -1638,7 +1638,7 @@
 }
 // prototype
 static void deleteRenderPasses(layer_data*);
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(device);
     layer_data* dev_data = get_my_data_ptr(key, layer_data_map);
@@ -1646,7 +1646,7 @@
     loader_platform_thread_lock_mutex(&globalLock);
     deletePipelines(dev_data);
     deleteRenderPasses(dev_data);
-    deleteCmdBuffers(dev_data);
+    deleteCommandBuffers(dev_data);
     deletePools(dev_data);
     deleteLayouts(dev_data);
     dev_data->imageViewMap.clear();
@@ -1737,15 +1737,15 @@
             pCB = getCBNode(dev_data, submit->pCommandBuffers[i]);
             loader_platform_thread_lock_mutex(&globalLock);
             pCB->submitCount++; // increment submit count
-            if ((pCB->beginInfo.flags & VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT) && (pCB->submitCount > 1)) {
-                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_CMD_BUFFER_SINGLE_SUBMIT_VIOLATION, "DS",
-                        "CB %#" PRIxLEAST64 " was begun w/ VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted %#" PRIxLEAST64 " times.", reinterpret_cast<uint64_t>(pCB->cmdBuffer), pCB->submitCount);
+            if ((pCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT) && (pCB->submitCount > 1)) {
+                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION, "DS",
+                        "CB %#" PRIxLEAST64 " was begun w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted %#" PRIxLEAST64 " times.", reinterpret_cast<uint64_t>(pCB->commandBuffer), pCB->submitCount);
             }
             if (CB_UPDATE_COMPLETE != pCB->state) {
                 // Flag error for using CB w/o vkEndCommandBuffer() called
                 // TODO : How to pass cb as srcObj?
-                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_END_CMD_BUFFER, "DS",
-                        "You must call vkEndCommandBuffer() on CB %#" PRIxLEAST64 " before this call to vkQueueSubmit()!", reinterpret_cast<uint64_t>(pCB->cmdBuffer));
+                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_END_COMMAND_BUFFER, "DS",
+                        "You must call vkEndCommandBuffer() on CB %#" PRIxLEAST64 " before this call to vkQueueSubmit()!", reinterpret_cast<uint64_t>(pCB->commandBuffer));
                 loader_platform_thread_unlock_mutex(&globalLock);
                 return VK_ERROR_VALIDATION_FAILED;
             }
@@ -1757,119 +1757,119 @@
     return VK_ERROR_VALIDATION_FAILED;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFence(device, fence, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySemaphore(device, semaphore, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyEvent(device, event, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyQueryPool(device, queryPool, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     dev_data->device_dispatch_table->DestroyBuffer(device, buffer, pAllocator);
     dev_data->bufferMap.erase(buffer);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     dev_data->device_dispatch_table->DestroyBufferView(device, bufferView, pAllocator);
     dev_data->bufferViewMap.erase(bufferView);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     dev_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
     dev_data->imageMap.erase(image);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyImageView(device, imageView, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyShaderModule(device, shaderModule, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     dev_data->device_dispatch_table->DestroyShader(device, shader, pAllocator);
     dev_data->shaderStageMap.erase(shader);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipeline(device, pipeline, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySampler(device, sampler, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorPool(device, descriptorPool, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer *pCommandBuffers)
+VK_LAYER_EXPORT void VKAPI vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t count, const VkCommandBuffer *pCommandBuffers)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->FreeCommandBuffers(device, commandPool, count, pCommandBuffers);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFramebuffer(device, framebuffer, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
 {
     get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyRenderPass(device, renderPass, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
@@ -1882,7 +1882,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pAllocator, pView);
@@ -1894,7 +1894,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
@@ -1906,7 +1906,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView);
@@ -1921,7 +1921,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
         VkDevice device,
         const VkShaderCreateInfo *pCreateInfo,
-        const VkAllocCallbacks* pAllocator,
+        const VkAllocationCallbacks* pAllocator,
         VkShader *pShader)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1940,7 +1940,7 @@
 VkResult VKAPI vkCreatePipelineCache(
     VkDevice                                    device,
     const VkPipelineCacheCreateInfo*            pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkPipelineCache*                            pPipelineCache)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1951,7 +1951,7 @@
 void VKAPI vkDestroyPipelineCache(
     VkDevice                                    device,
     VkPipelineCache                             pipelineCache,
-    const VkAllocCallbacks* pAllocator)
+    const VkAllocationCallbacks* pAllocator)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     dev_data->device_dispatch_table->DestroyPipelineCache(device, pipelineCache, pAllocator);
@@ -1970,16 +1970,16 @@
 
 VkResult VKAPI vkMergePipelineCaches(
     VkDevice                                    device,
-    VkPipelineCache                             destCache,
+    VkPipelineCache                             dstCache,
     uint32_t                                    srcCacheCount,
     const VkPipelineCache*                      pSrcCaches)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
+    VkResult result = dev_data->device_dispatch_table->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
 {
     VkResult result = VK_SUCCESS;
     //TODO What to do with pipelineCache?
@@ -2021,7 +2021,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->device_dispatch_table->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
@@ -2033,7 +2033,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->device_dispatch_table->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
@@ -2082,7 +2082,7 @@
     return result;
 }
 
-VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
@@ -2101,7 +2101,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->device_dispatch_table->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
@@ -2136,36 +2136,36 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets)
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     // Verify that requested descriptorSets are available in pool
-    POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocInfo->descriptorPool);
+    POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocateInfo->descriptorPool);
     if (!pPoolNode) {
-        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pAllocInfo->descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS",
-                "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pAllocInfo->descriptorPool);
+        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pAllocateInfo->descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS",
+                "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocateDescriptorSets() call", (uint64_t) pAllocateInfo->descriptorPool);
     } else { // Make sure pool has all the available descriptors before calling down chain
-        skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, pAllocInfo->setLayoutCount, pAllocInfo->pSetLayouts);
+        skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, pAllocateInfo->setLayoutCount, pAllocateInfo->pSetLayouts);
     }
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED;
-    VkResult result = dev_data->device_dispatch_table->AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
+    VkResult result = dev_data->device_dispatch_table->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
     if (VK_SUCCESS == result) {
-        POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocInfo->descriptorPool);
+        POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocateInfo->descriptorPool);
         if (pPoolNode) {
-            if (pAllocInfo->setLayoutCount == 0) {
-                log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pAllocInfo->setLayoutCount, 0, DRAWSTATE_NONE, "DS",
-                        "AllocDescriptorSets called with 0 count");
+            if (pAllocateInfo->setLayoutCount == 0) {
+                log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pAllocateInfo->setLayoutCount, 0, DRAWSTATE_NONE, "DS",
+                        "AllocateDescriptorSets called with 0 count");
             }
-            for (uint32_t i = 0; i < pAllocInfo->setLayoutCount; i++) {
+            for (uint32_t i = 0; i < pAllocateInfo->setLayoutCount; i++) {
                 log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS",
                         "Created Descriptor Set %#" PRIxLEAST64, (uint64_t) pDescriptorSets[i]);
                 // Create new set node and add to head of pool nodes
                 SET_NODE* pNewNode = new SET_NODE;
                 if (NULL == pNewNode) {
                     if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
-                            "Out of memory while attempting to allocate SET_NODE in vkAllocDescriptorSets()"))
+                            "Out of memory while attempting to allocate SET_NODE in vkAllocateDescriptorSets()"))
                         return VK_ERROR_VALIDATION_FAILED;
                 } else {
                     memset(pNewNode, 0, sizeof(SET_NODE));
@@ -2175,14 +2175,14 @@
                     // Insert set at head of Set LL for this pool
                     pNewNode->pNext = pPoolNode->pSets;
                     pPoolNode->pSets = pNewNode;
-                    LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pAllocInfo->pSetLayouts[i]);
+                    LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pAllocateInfo->pSetLayouts[i]);
                     if (NULL == pLayout) {
-                        if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pAllocInfo->pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
-                                "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pAllocInfo->pSetLayouts[i]))
+                        if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pAllocateInfo->pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
+                                "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocateDescriptorSets() call", (uint64_t) pAllocateInfo->pSetLayouts[i]))
                             return VK_ERROR_VALIDATION_FAILED;
                     }
                     pNewNode->pLayout = pLayout;
-                    pNewNode->pool = pAllocInfo->descriptorPool;
+                    pNewNode->pool = pAllocateInfo->descriptorPool;
                     pNewNode->set = pDescriptorSets[i];
                     pNewNode->descriptorCount = pLayout->endIndex + 1;
                     if (pNewNode->descriptorCount) {
@@ -2237,84 +2237,84 @@
     }
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pCreateInfo, VkCommandBuffer* pCommandBuffer)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
+    VkResult result = dev_data->device_dispatch_table->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         GLOBAL_CB_NODE* pCB = new GLOBAL_CB_NODE;
         memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
-        pCB->cmdBuffer = *pCmdBuffer;
+        pCB->commandBuffer = *pCommandBuffer;
         pCB->createInfo = *pCreateInfo;
         pCB->lastVtxBinding = MAX_BINDING;
         pCB->level = pCreateInfo->level;
-        dev_data->cmdBufferMap[*pCmdBuffer] = pCB;
+        dev_data->commandBufferMap[*pCommandBuffer] = pCB;
         loader_platform_thread_unlock_mutex(&globalLock);
         updateCBTracking(pCB);
     }
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
+VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
 {
     VkBool32 skipCall = false;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // Validate command buffer level
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
-        if (pCB->level == VK_CMD_BUFFER_LEVEL_PRIMARY) {
+        if (pCB->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) {
             if (pBeginInfo->renderPass || pBeginInfo->framebuffer) {
                 // These should be NULL for a Primary CB
                 skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
-                    "vkAllocCommandBuffers():  Primary Command Buffer (%p) may not specify framebuffer or renderpass parameters", (void*)cmdBuffer);
+                    "vkAllocateCommandBuffers():  Primary Command Buffer (%p) may not specify framebuffer or renderpass parameters", (void*)commandBuffer);
             }
         } else {
             if (!pBeginInfo->renderPass || !pBeginInfo->framebuffer) {
                 // These should NOT be null for an Secondary CB
                 skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
-                    "vkAllocCommandBuffers():  Secondary Command Buffers (%p) must specify framebuffer and renderpass parameters", (void*)cmdBuffer);
+                    "vkAllocateCommandBuffers():  Secondary Command Buffers (%p) must specify framebuffer and renderpass parameters", (void*)commandBuffer);
             }
         }
         pCB->beginInfo = *pBeginInfo;
     } else {
-        // TODO : Need to pass cmdBuffer as objType here
-        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS",
-                "In vkBeginCommandBuffer() and unable to find CmdBuffer Node for CB %p!", (void*)cmdBuffer);
+        // TODO : Need to pass commandBuffer as objType here
+        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS",
+                "In vkBeginCommandBuffer() and unable to find CommandBuffer Node for CB %p!", (void*)commandBuffer);
     }
     if (skipCall) {
         return VK_ERROR_VALIDATION_FAILED;
     }
-    VkResult result = dev_data->device_dispatch_table->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+    VkResult result = dev_data->device_dispatch_table->BeginCommandBuffer(commandBuffer, pBeginInfo);
     if (VK_SUCCESS == result) {
         if (CB_NEW != pCB->state)
-            resetCB(dev_data, cmdBuffer);
+            resetCB(dev_data, commandBuffer);
         pCB->state = CB_UPDATE_ACTIVE;
         updateCBTracking(pCB);
     }
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCommandBuffer commandBuffer)
 {
     VkBool32 skipCall = VK_FALSE;
     VkResult result = VK_SUCCESS;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     /* TODO: preference is to always call API function after reporting any validation errors */
     if (pCB) {
         if (pCB->state != CB_UPDATE_ACTIVE) {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkEndCommandBuffer()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkEndCommandBuffer()");
         }
     }
     if (VK_FALSE == skipCall) {
-        result = dev_data->device_dispatch_table->EndCommandBuffer(cmdBuffer);
+        result = dev_data->device_dispatch_table->EndCommandBuffer(commandBuffer);
         if (VK_SUCCESS == result) {
             updateCBTracking(pCB);
             pCB->state = CB_UPDATE_COMPLETE;
             // Reset CB status flags
             pCB->status = 0;
-            printCB(dev_data, cmdBuffer);
+            printCB(dev_data, commandBuffer);
         }
     } else {
         result = VK_ERROR_VALIDATION_FAILED;
@@ -2322,22 +2322,22 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags)
+VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 {
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->ResetCommandBuffer(cmdBuffer, flags);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    VkResult result = dev_data->device_dispatch_table->ResetCommandBuffer(commandBuffer, flags);
     if (VK_SUCCESS == result) {
-        resetCB(dev_data, cmdBuffer);
-        updateCBTracking(getCBNode(dev_data, cmdBuffer));
+        resetCB(dev_data, commandBuffer);
+        updateCBTracking(getCBNode(dev_data, commandBuffer));
     }
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
@@ -2367,21 +2367,21 @@
                 }
             }
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBindPipeline()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindPipeline()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+        dev_data->device_dispatch_table->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     uint32_t                            viewportCount,
     const VkViewport*                   pViewports)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
@@ -2392,21 +2392,21 @@
             memcpy(pCB->viewports.data(), pViewports, viewportCount * sizeof(VkViewport));
             loader_platform_thread_unlock_mutex(&globalLock);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetViewport()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetViewport()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetViewport(cmdBuffer, viewportCount, pViewports);
+        dev_data->device_dispatch_table->CmdSetViewport(commandBuffer, viewportCount, pViewports);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     uint32_t                            scissorCount,
     const VkRect2D*                     pScissors)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
@@ -2417,18 +2417,18 @@
             memcpy(pCB->scissors.data(), pScissors, scissorCount * sizeof(VkRect2D));
             loader_platform_thread_unlock_mutex(&globalLock);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetScissor()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetScissor()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetScissor(cmdBuffer, scissorCount, pScissors);
+        dev_data->device_dispatch_table->CmdSetScissor(commandBuffer, scissorCount, pScissors);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth)
+VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
@@ -2439,22 +2439,22 @@
             pCB->lineWidth = lineWidth;
             loader_platform_thread_unlock_mutex(&globalLock);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBindDynamicLineWidthState()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindDynamicLineWidthState()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetLineWidth(cmdBuffer, lineWidth);
+        dev_data->device_dispatch_table->CmdSetLineWidth(commandBuffer, lineWidth);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBias(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     float                               depthBiasConstantFactor,
     float                               depthBiasClamp,
     float                               depthBiasSlopeFactor)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
@@ -2464,18 +2464,18 @@
             pCB->depthBiasClamp = depthBiasClamp;
             pCB->depthBiasSlopeFactor = depthBiasSlopeFactor;
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetDepthBias()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetDepthBias()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetDepthBias(cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+        dev_data->device_dispatch_table->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConstants[4])
+VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
@@ -2483,21 +2483,21 @@
             pCB->status |= CBSTATUS_BLEND_SET;
             memcpy(pCB->blendConstants, blendConstants, 4 * sizeof(float));
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetBlendConstants()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetBlendConstants()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetBlendConstants(cmdBuffer, blendConstants);
+        dev_data->device_dispatch_table->CmdSetBlendConstants(commandBuffer, blendConstants);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBounds(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     float                               minDepthBounds,
     float                               maxDepthBounds)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
@@ -2506,21 +2506,21 @@
             pCB->minDepthBounds = minDepthBounds;
             pCB->maxDepthBounds = maxDepthBounds;
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetDepthBounds()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetDepthBounds()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds);
+        dev_data->device_dispatch_table->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     VkStencilFaceFlags                  faceMask,
     uint32_t                            stencilCompareMask)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
@@ -2535,21 +2535,21 @@
             /* TODO: We aren't capturing the faceMask, do we need to? */
             pCB->status |= CBSTATUS_STENCIL_READ_MASK_SET;
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetStencilCompareMask()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetStencilCompareMask()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask);
+        dev_data->device_dispatch_table->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     VkStencilFaceFlags                  faceMask,
     uint32_t                            stencilWriteMask)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
@@ -2562,21 +2562,21 @@
             }
             pCB->status |= CBSTATUS_STENCIL_WRITE_MASK_SET;
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetStencilWriteMask()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetStencilWriteMask()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask);
+        dev_data->device_dispatch_table->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     VkStencilFaceFlags                  faceMask,
     uint32_t                            stencilReference)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
@@ -2589,18 +2589,18 @@
             }
             pCB->status |= CBSTATUS_STENCIL_REFERENCE_SET;
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetStencilReference()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetStencilReference()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
+        dev_data->device_dispatch_table->CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+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)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     // TODO : Validate dynamic offsets
     //  If any of the sets being bound include dynamic uniform or storage buffers,
     //  then pDynamicOffsets must include one element for each array element
@@ -2638,18 +2638,18 @@
                 skipCall |= addCmd(dev_data, pCB, CMD_BINDDESCRIPTORSETS);
             }
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBindDescriptorSets()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindDescriptorSets()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+        dev_data->device_dispatch_table->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             VkDeviceSize offset_align = 0;
@@ -2669,26 +2669,26 @@
                     "vkCmdBindIndexBuffer() offset (%#" PRIxLEAST64 ") does not fall on alignment (%s) boundary.", offset, string_VkIndexType(indexType));
             }
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBindIndexBuffer()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindIndexBuffer()");
         }
         pCB->status |= CBSTATUS_INDEX_BUFFER_BOUND;
         updateCBTracking(pCB);
         skipCall |= addCmd(dev_data, pCB, CMD_BINDINDEXBUFFER);
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+        dev_data->device_dispatch_table->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     uint32_t                                    startBinding,
     uint32_t                                    bindingCount,
     const VkBuffer*                             pBuffers,
     const VkDeviceSize*                         pOffsets)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             /* TODO: Need to track all the vertex buffers, not just last one */
@@ -2696,317 +2696,317 @@
             updateCBTracking(pCB);
             addCmd(dev_data, pCB, CMD_BINDVERTEXBUFFER);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBindVertexBuffer()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindVertexBuffer()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+        dev_data->device_dispatch_table->CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             pCB->drawCount[DRAW]++;
             skipCall |= validate_draw_state(dev_data, pCB, VK_FALSE);
-            // TODO : Need to pass cmdBuffer as srcObj here
+            // TODO : Need to pass commandBuffer as srcObj here
             skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
                     "vkCmdDraw() call #%lu, reporting DS state:", g_drawCount[DRAW]++);
-            skipCall |= synchAndPrintDSConfig(dev_data, cmdBuffer);
+            skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
             if (VK_FALSE == skipCall) {
                 updateCBTracking(pCB);
                 skipCall |= addCmd(dev_data, pCB, CMD_DRAW);
             }
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDraw()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDraw()");
         }
         skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDraw");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdDraw(cmdBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+        dev_data->device_dispatch_table->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
 {
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     VkBool32 skipCall = VK_FALSE;
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             pCB->drawCount[DRAW_INDEXED]++;
             skipCall |= validate_draw_state(dev_data, pCB, VK_TRUE);
-            // TODO : Need to pass cmdBuffer as srcObj here
+            // TODO : Need to pass commandBuffer as srcObj here
             skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
                     "vkCmdDrawIndexed() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED]++);
-            skipCall |= synchAndPrintDSConfig(dev_data, cmdBuffer);
+            skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
             if (VK_FALSE == skipCall) {
                 updateCBTracking(pCB);
                 skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDEXED);
             }
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDrawIndexed()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDrawIndexed()");
         }
         skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndexed");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdDrawIndexed(cmdBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+        dev_data->device_dispatch_table->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
 {
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     VkBool32 skipCall = VK_FALSE;
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             pCB->drawCount[DRAW_INDIRECT]++;
             skipCall |= validate_draw_state(dev_data, pCB, VK_FALSE);
-            // TODO : Need to pass cmdBuffer as srcObj here
+            // TODO : Need to pass commandBuffer as srcObj here
             skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
                     "vkCmdDrawIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDIRECT]++);
-            skipCall |= synchAndPrintDSConfig(dev_data, cmdBuffer);
+            skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
             if (VK_FALSE == skipCall) {
                 updateCBTracking(pCB);
                 skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDIRECT);
             }
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDrawIndirect()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDrawIndirect()");
         }
         skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndirect");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+        dev_data->device_dispatch_table->CmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
+VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             pCB->drawCount[DRAW_INDEXED_INDIRECT]++;
             skipCall |= validate_draw_state(dev_data, pCB, VK_TRUE);
-            // TODO : Need to pass cmdBuffer as srcObj here
+            // TODO : Need to pass commandBuffer as srcObj here
             skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS",
                     "vkCmdDrawIndexedIndirect() call #%lu, reporting DS state:", g_drawCount[DRAW_INDEXED_INDIRECT]++);
-            skipCall |= synchAndPrintDSConfig(dev_data, cmdBuffer);
+            skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
             if (VK_FALSE == skipCall) {
                 updateCBTracking(pCB);
                 skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDEXEDINDIRECT);
             }
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDrawIndexedIndirect()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDrawIndexedIndirect()");
         }
         skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndexedIndirect");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+        dev_data->device_dispatch_table->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_DISPATCH);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDispatch()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDispatch()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdDispatch");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdDispatch(cmdBuffer, x, y, z);
+        dev_data->device_dispatch_table->CmdDispatch(commandBuffer, x, y, z);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset)
+VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_DISPATCHINDIRECT);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdDispatchIndirect()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdDispatchIndirect()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdDispatchIndirect");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdDispatchIndirect(cmdBuffer, buffer, offset);
+        dev_data->device_dispatch_table->CmdDispatchIndirect(commandBuffer, buffer, offset);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_COPYBUFFER);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdCopyBuffer()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyBuffer()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyBuffer");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+        dev_data->device_dispatch_table->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer,
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCommandBuffer commandBuffer,
                                              VkImage srcImage,
                                              VkImageLayout srcImageLayout,
-                                             VkImage destImage,
-                                             VkImageLayout destImageLayout,
+                                             VkImage dstImage,
+                                             VkImageLayout dstImageLayout,
                                              uint32_t regionCount, const VkImageCopy* pRegions)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_COPYIMAGE);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdCopyImage()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyImage()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyImage");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+        dev_data->device_dispatch_table->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer,
+VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCommandBuffer commandBuffer,
                                              VkImage srcImage, VkImageLayout srcImageLayout,
-                                             VkImage destImage, VkImageLayout destImageLayout,
+                                             VkImage dstImage, VkImageLayout dstImageLayout,
                                              uint32_t regionCount, const VkImageBlit* pRegions,
                                              VkFilter filter)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_BLITIMAGE);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBlitImage()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBlitImage()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdBlitImage");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+        dev_data->device_dispatch_table->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer,
+VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,
                                                      VkBuffer srcBuffer,
-                                                     VkImage destImage, VkImageLayout destImageLayout,
+                                                     VkImage dstImage, VkImageLayout dstImageLayout,
                                                      uint32_t regionCount, const VkBufferImageCopy* pRegions)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_COPYBUFFERTOIMAGE);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdCopyBufferToImage()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyBufferToImage()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyBufferToImage");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+        dev_data->device_dispatch_table->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer,
+VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
                                                      VkImage srcImage, VkImageLayout srcImageLayout,
-                                                     VkBuffer destBuffer,
+                                                     VkBuffer dstBuffer,
                                                      uint32_t regionCount, const VkBufferImageCopy* pRegions)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_COPYIMAGETOBUFFER);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdCopyImageToBuffer()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyImageToBuffer()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyImageToBuffer");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+        dev_data->device_dispatch_table->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData)
+VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_UPDATEBUFFER);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdUpdateBuffer()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdUpdateBuffer()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyUpdateBuffer");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+        dev_data->device_dispatch_table->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data)
+VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_FILLBUFFER);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdFillBuffer()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdFillBuffer()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyFillBuffer");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+        dev_data->device_dispatch_table->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearAttachments(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     uint32_t                                    attachmentCount,
     const VkClearAttachment*                    pAttachments,
     uint32_t                                    rectCount,
     const VkClearRect*                          pRects)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             // Warn if this is issued prior to Draw Cmd
             if (!hasDrawCmd(pCB)) {
-                // TODO : cmdBuffer should be srcObj
+                // TODO : commandBuffer should be srcObj
                 skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, "DS",
                         "vkCmdClearAttachments() issued on CB object 0x%" PRIxLEAST64 " prior to any Draw Cmds."
-                        " It is recommended you use RenderPass LOAD_OP_CLEAR on Attachments prior to any Draw.", reinterpret_cast<uint64_t>(cmdBuffer));
+                        " It is recommended you use RenderPass LOAD_OP_CLEAR on Attachments prior to any Draw.", reinterpret_cast<uint64_t>(commandBuffer));
             }
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_CLEARATTACHMENTS);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdClearAttachments()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdClearAttachments()");
         }
         skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdClearAttachments");
     }
@@ -3028,7 +3028,7 @@
                 }
                 if (VK_FALSE == found) {
                     skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                            (uint64_t)cmdBuffer, 0, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS",
+                            (uint64_t)commandBuffer, 0, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS",
                             "vkCmdClearAttachments() attachment index %d not found in attachment reference array of active subpass %d",
                             attachment->colorAttachment, pCB->activeSubpass);
                 }
@@ -3036,7 +3036,7 @@
                 /* TODO: Is this a good test for depth/stencil? */
                 if (!pSD->pDepthStencilAttachment || pSD->pDepthStencilAttachment->attachment != attachment->colorAttachment) {
                     skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                            (uint64_t)cmdBuffer, 0, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS",
+                            (uint64_t)commandBuffer, 0, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS",
                             "vkCmdClearAttachments() attachment index %d does not match depthStencilAttachment.attachment (%d) found in active subpass %d",
                             attachment->colorAttachment,
                             (pSD->pDepthStencilAttachment) ? pSD->pDepthStencilAttachment->attachment : VK_ATTACHMENT_UNUSED,
@@ -3046,236 +3046,236 @@
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdClearAttachments(cmdBuffer, attachmentCount, pAttachments, rectCount, pRects);
+        dev_data->device_dispatch_table->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
-        VkCmdBuffer cmdBuffer,
+        VkCommandBuffer commandBuffer,
         VkImage image, VkImageLayout imageLayout,
         const VkClearColorValue *pColor,
         uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_CLEARCOLORIMAGE);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdClearColorImage()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdClearColorImage()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdClearColorImage");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+        dev_data->device_dispatch_table->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilImage(
-        VkCmdBuffer cmdBuffer,
+        VkCommandBuffer commandBuffer,
         VkImage image, VkImageLayout imageLayout,
         const VkClearDepthStencilValue *pDepthStencil,
         uint32_t rangeCount,
         const VkImageSubresourceRange* pRanges)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_CLEARDEPTHSTENCILIMAGE);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdClearDepthStencilImage()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdClearDepthStencilImage()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdClearDepthStencilImage");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+        dev_data->device_dispatch_table->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer,
+VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCommandBuffer commandBuffer,
                                                 VkImage srcImage, VkImageLayout srcImageLayout,
-                                                VkImage destImage, VkImageLayout destImageLayout,
+                                                VkImage dstImage, VkImageLayout dstImageLayout,
                                                 uint32_t regionCount, const VkImageResolve* pRegions)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_RESOLVEIMAGE);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdResolveImage()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdResolveImage()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdResolveImage");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+        dev_data->device_dispatch_table->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_SETEVENT);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdSetEvent()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdSetEvent()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdSetEvent");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdSetEvent(cmdBuffer, event, stageMask);
+        dev_data->device_dispatch_table->CmdSetEvent(commandBuffer, event, stageMask);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_RESETEVENT);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdResetEvent()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdResetEvent()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdResetEvent");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdResetEvent(cmdBuffer, event, stageMask);
+        dev_data->device_dispatch_table->CmdResetEvent(commandBuffer, event, stageMask);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers)
+VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_WAITEVENTS);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdWaitEvents()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWaitEvents()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
+        dev_data->device_dispatch_table->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers)
+VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_PIPELINEBARRIER);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdPipelineBarrier()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdPipelineBarrier()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, dependencyFlags, memBarrierCount, ppMemBarriers);
+        dev_data->device_dispatch_table->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_BEGINQUERY);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdBeginQuery()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBeginQuery()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+        dev_data->device_dispatch_table->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_ENDQUERY);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdEndQuery()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdEndQuery()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdEndQuery(cmdBuffer, queryPool, slot);
+        dev_data->device_dispatch_table->CmdEndQuery(commandBuffer, queryPool, slot);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
+VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_RESETQUERYPOOL);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdResetQueryPool()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdResetQueryPool()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdQueryPool");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+        dev_data->device_dispatch_table->CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery,
-                                                     uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset,
+VK_LAYER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery,
+                                                     uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
                                                      VkDeviceSize stride, VkQueryResultFlags flags)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_COPYQUERYPOOLRESULTS);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdCopyQueryPoolResults()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyQueryPoolResults()");
         }
         skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyQueryPoolResults");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdCopyQueryPoolResults(cmdBuffer, queryPool,
-                           startQuery, queryCount, destBuffer, destOffset, stride, flags);
+        dev_data->device_dispatch_table->CmdCopyQueryPoolResults(commandBuffer, queryPool,
+                           startQuery, queryCount, dstBuffer, dstOffset, stride, flags);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot)
+VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_WRITETIMESTAMP);
         } else {
-            skipCall |= report_error_no_cb_begin(dev_data, cmdBuffer, "vkCmdWriteTimestamp()");
+            skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWriteTimestamp()");
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
+        dev_data->device_dispatch_table->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->device_dispatch_table->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
@@ -3393,12 +3393,12 @@
     }
     for (uint32_t i = 0; i < pCreateInfo->dependencyCount; ++i) {
         const VkSubpassDependency& dependency = pCreateInfo->pDependencies[i];
-        if (dependency.srcSubpass > dependency.destSubpass) {
+        if (dependency.srcSubpass > dependency.dstSubpass) {
             skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS",
                                  "Dependency graph must be specified such that an earlier pass cannot depend on a later pass.");
         }
-        subpass_to_node[dependency.destSubpass].prev.push_back(dependency.srcSubpass);
-        subpass_to_node[dependency.srcSubpass].next.push_back(dependency.destSubpass);
+        subpass_to_node[dependency.dstSubpass].prev.push_back(dependency.srcSubpass);
+        subpass_to_node[dependency.srcSubpass].next.push_back(dependency.dstSubpass);
     }
     // Find for each attachment the subpasses that use them.
     for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) {
@@ -3443,7 +3443,7 @@
     return skip_call;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     if (validateDependencies(dev_data, device, pCreateInfo)) {
@@ -3536,11 +3536,11 @@
     }
     my_data->renderPassMap.clear();
 }
-VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkRenderPassContents contents)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkRenderPassContents contents)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         if (pRenderPassBegin && pRenderPassBegin->renderPass) {
             skipCall |= insideRenderPass(dev_data, pCB, "vkCmdBeginRenderPass");
@@ -3558,14 +3558,14 @@
         }
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
+        dev_data->device_dispatch_table->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents)
+VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkRenderPassContents contents)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         updateCBTracking(pCB);
         skipCall |= addCmd(dev_data, pCB, CMD_NEXTSUBPASS);
@@ -3576,14 +3576,14 @@
         skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdNextSubpass");
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdNextSubpass(cmdBuffer, contents);
+        dev_data->device_dispatch_table->CmdNextSubpass(commandBuffer, contents);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer)
+VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         skipCall |= outsideRenderPass(dev_data, pCB, "vkEndRenderpass");
         updateCBTracking(pCB);
@@ -3592,31 +3592,31 @@
         pCB->activeSubpass = 0;
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdEndRenderPass(cmdBuffer);
+        dev_data->device_dispatch_table->CmdEndRenderPass(commandBuffer);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers)
+VK_LAYER_EXPORT void VKAPI vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (pCB) {
         GLOBAL_CB_NODE* pSubCB = NULL;
-        for (uint32_t i=0; i<cmdBuffersCount; i++) {
-            pSubCB = getCBNode(dev_data, pCmdBuffers[i]);
+        for (uint32_t i=0; i<commandBuffersCount; i++) {
+            pSubCB = getCBNode(dev_data, pCommandBuffers[i]);
             if (!pSubCB) {
-                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_CMD_BUFFER, "DS",
-                    "vkCmdExecuteCommands() called w/ invalid Cmd Buffer %p in element %u of pCmdBuffers array.", (void*)pCmdBuffers[i], i);
-            } else if (VK_CMD_BUFFER_LEVEL_PRIMARY == pSubCB->createInfo.level) {
-                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_CMD_BUFFER, "DS",
-                    "vkCmdExecuteCommands() called w/ Primary Cmd Buffer %p in element %u of pCmdBuffers array. All cmd buffers in pCmdBuffers array must be secondary.", (void*)pCmdBuffers[i], i);
+                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS",
+                    "vkCmdExecuteCommands() called w/ invalid Cmd Buffer %p in element %u of pCommandBuffers array.", (void*)pCommandBuffers[i], i);
+            } else if (VK_COMMAND_BUFFER_LEVEL_PRIMARY == pSubCB->createInfo.level) {
+                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS",
+                    "vkCmdExecuteCommands() called w/ Primary Cmd Buffer %p in element %u of pCommandBuffers array. All cmd buffers in pCommandBuffers array must be secondary.", (void*)pCommandBuffers[i], i);
             }
         }
         updateCBTracking(pCB);
         skipCall |= addCmd(dev_data, pCB, CMD_EXECUTECOMMANDS);
     }
     if (VK_FALSE == skipCall)
-        dev_data->device_dispatch_table->CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
+        dev_data->device_dispatch_table->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
@@ -3647,13 +3647,13 @@
     return res;
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCommandBuffer commandBuffer, const char* pMarker)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (!dev_data->device_extensions.debug_marker_enabled) {
-        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
+        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
                 "Attempt to use CmdDbgMarkerBegin but extension disabled!");
         return;
     } else if (pCB) {
@@ -3661,16 +3661,16 @@
         skipCall |= addCmd(dev_data, pCB, CMD_DBGMARKERBEGIN);
     }
     if (VK_FALSE == skipCall)
-        debug_marker_dispatch_table(cmdBuffer)->CmdDbgMarkerBegin(cmdBuffer, pMarker);
+        debug_marker_dispatch_table(commandBuffer)->CmdDbgMarkerBegin(commandBuffer, pMarker);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer)
+VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCommandBuffer commandBuffer)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer);
     if (!dev_data->device_extensions.debug_marker_enabled) {
-        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
+        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS",
                 "Attempt to use CmdDbgMarkerEnd but extension disabled!");
         return;
     } else if (pCB) {
@@ -3678,7 +3678,7 @@
         skipCall |= addCmd(dev_data, pCB, CMD_DBGMARKEREND);
     }
     if (VK_FALSE == skipCall)
-        debug_marker_dispatch_table(cmdBuffer)->CmdDbgMarkerEnd(cmdBuffer);
+        debug_marker_dispatch_table(commandBuffer)->CmdDbgMarkerEnd(commandBuffer);
 }
 
 VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcName)
@@ -3772,14 +3772,14 @@
         return (PFN_vkVoidFunction) vkCreateDescriptorPool;
     if (!strcmp(funcName, "vkResetDescriptorPool"))
         return (PFN_vkVoidFunction) vkResetDescriptorPool;
-    if (!strcmp(funcName, "vkAllocDescriptorSets"))
-        return (PFN_vkVoidFunction) vkAllocDescriptorSets;
+    if (!strcmp(funcName, "vkAllocateDescriptorSets"))
+        return (PFN_vkVoidFunction) vkAllocateDescriptorSets;
     if (!strcmp(funcName, "vkFreeDescriptorSets"))
         return (PFN_vkVoidFunction) vkFreeDescriptorSets;
     if (!strcmp(funcName, "vkUpdateDescriptorSets"))
         return (PFN_vkVoidFunction) vkUpdateDescriptorSets;
-    if (!strcmp(funcName, "vkAllocCommandBuffers"))
-        return (PFN_vkVoidFunction) vkAllocCommandBuffers;
+    if (!strcmp(funcName, "vkAllocateCommandBuffers"))
+        return (PFN_vkVoidFunction) vkAllocateCommandBuffers;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
         return (PFN_vkVoidFunction) vkBeginCommandBuffer;
     if (!strcmp(funcName, "vkEndCommandBuffer"))
diff --git a/layers/draw_state.h b/layers/draw_state.h
index 6ded670..a5833fd 100755
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -39,7 +39,7 @@
     DRAWSTATE_INVALID_LAYOUT,                   // Invalid DS layout
     DRAWSTATE_INVALID_PIPELINE,                 // Invalid Pipeline handle referenced
     DRAWSTATE_INVALID_PIPELINE_CREATE_STATE,    // Attempt to create a pipeline with invalid state
-    DRAWSTATE_INVALID_CMD_BUFFER,               // Invalid CmdBuffer referenced
+    DRAWSTATE_INVALID_COMMAND_BUFFER,               // Invalid CommandBuffer referenced
     DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS,          // binding in vkCmdBindVertexData() too large for PSO's pVertexBindingDescriptions array
     DRAWSTATE_VTX_INDEX_ALIGNMENT_ERROR,        // binding offset in vkCmdBindIndexBuffer() out of alignment based on indexType
     //DRAWSTATE_MISSING_DOT_PROGRAM,              // No "dot" program in order to generate png image
@@ -52,10 +52,10 @@
     DRAWSTATE_INVALID_UPDATE_INDEX,             // Index of requested update is invalid for specified descriptors set
     DRAWSTATE_INVALID_UPDATE_STRUCT,            // Struct in DS Update tree is of invalid type
     DRAWSTATE_NUM_SAMPLES_MISMATCH,             // Number of samples in bound PSO does not match number in FB of current RenderPass
-    DRAWSTATE_NO_END_CMD_BUFFER,                // Must call vkEndCommandBuffer() before QueueSubmit on that cmdBuffer
-    DRAWSTATE_NO_BEGIN_CMD_BUFFER,              // Binding cmds or calling End on CB that never had vkBeginCommandBuffer() called on it
-    DRAWSTATE_CMD_BUFFER_SINGLE_SUBMIT_VIOLATION, // Cmd Buffer created with VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT flag is submitted multiple times
-    DRAWSTATE_INVALID_SECONDARY_CMD_BUFFER,     // vkCmdExecuteCommands() called with a primary cmdBuffer in pCmdBuffers array
+    DRAWSTATE_NO_END_COMMAND_BUFFER,                // Must call vkEndCommandBuffer() before QueueSubmit on that commandBuffer
+    DRAWSTATE_NO_BEGIN_COMMAND_BUFFER,              // Binding cmds or calling End on CB that never had vkBeginCommandBuffer() called on it
+    DRAWSTATE_COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION, // Cmd Buffer created with VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT flag is submitted multiple times
+    DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER,     // vkCmdExecuteCommands() called with a primary commandBuffer in pCommandBuffers array
     DRAWSTATE_VIEWPORT_NOT_BOUND,               // Draw submitted with no viewport state bound
     DRAWSTATE_SCISSOR_NOT_BOUND,                // Draw submitted with no scissor state bound
     DRAWSTATE_LINE_WIDTH_NOT_BOUND,             // Draw submitted with no line width state bound
@@ -69,7 +69,7 @@
     DRAWSTATE_INVALID_RENDERPASS_CMD,           // Invalid cmd submitted while a RenderPass is active
     DRAWSTATE_NO_ACTIVE_RENDERPASS,             // Rendering cmd submitted without an active RenderPass
     DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED,       // DescriptorSet bound but it was never updated. This is a warning code.
-    DRAWSTATE_CLEAR_CMD_BEFORE_DRAW,            // Clear cmd issued before any Draw in CmdBuffer, should use RenderPass Ops instead
+    DRAWSTATE_CLEAR_CMD_BEFORE_DRAW,            // Clear cmd issued before any Draw in CommandBuffer, should use RenderPass Ops instead
     DRAWSTATE_BEGIN_CB_INVALID_STATE,           // Primary/Secondary CB created with mismatched FB/RP information
     DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH,        // Count for viewports and scissors mismatch and/or state doesn't match count
     DRAWSTATE_INVALID_IMAGE_ASPECT,             // Image aspect is invalid for the current operation
@@ -110,7 +110,7 @@
     VkPipelineInputAssemblyStateCreateInfo  iaStateCI;
     VkPipelineTessellationStateCreateInfo   tessStateCI;
     VkPipelineViewportStateCreateInfo       vpStateCI;
-    VkPipelineRasterStateCreateInfo         rsStateCI;
+    VkPipelineRasterizationStateCreateInfo         rsStateCI;
     VkPipelineMultisampleStateCreateInfo    msStateCI;
     VkPipelineColorBlendStateCreateInfo     cbStateCI;
     VkPipelineDepthStencilStateCreateInfo   dsStateCI;
@@ -303,9 +303,9 @@
 
 // Cmd Buffer Wrapper Struct
 typedef struct _GLOBAL_CB_NODE {
-    VkCmdBuffer                  cmdBuffer;
-    VkCmdBufferAllocInfo        createInfo;
-    VkCmdBufferBeginInfo         beginInfo;
+    VkCommandBuffer                  commandBuffer;
+    VkCommandBufferAllocateInfo        createInfo;
+    VkCommandBufferBeginInfo         beginInfo;
     VkFence                      fence;    // fence tracking this cmd buffer
     uint64_t                     numCmds;  // number of cmds in this CB
     uint64_t                     drawCount[NUM_DRAW_TYPES]; // Count of each type of draw in this CB
@@ -334,6 +334,6 @@
     VkRenderPass                 activeRenderPass;
     uint32_t                     activeSubpass;
     VkFramebuffer                framebuffer;
-    VkCmdBufferLevel             level;
+    VkCommandBufferLevel             level;
     vector<VkDescriptorSet>      boundDescriptorSets;
 } GLOBAL_CB_NODE;
diff --git a/layers/generic.h b/layers/generic.h
index c1e5621..cc1c7a6 100644
--- a/layers/generic.h
+++ b/layers/generic.h
@@ -48,7 +48,7 @@
     {
         "Generic",
         VK_API_VERSION,                 // specVersion
-        VK_MAKE_VERSION(0, 1, 0),       // implVersion
+        VK_MAKE_VERSION(0, 1, 0),       // implementationVersion
         "layer: Generic",
     }
 };
@@ -57,7 +57,7 @@
     {
         "Generic",
         VK_API_VERSION,                 // specVersion
-        VK_MAKE_VERSION(0, 1, 0),       // implVersion
+        VK_MAKE_VERSION(0, 1, 0),       // implementationVersion
         "layer: Generic",
     }
 };
diff --git a/layers/image.cpp b/layers/image.cpp
index b9d49b3..f63a9af 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -112,7 +112,7 @@
     return res;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
@@ -127,7 +127,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
 {
     // Grab the key before the instance is destroyed.
     dispatch_key key = get_dispatch_key(instance);
@@ -148,7 +148,7 @@
 
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
 {
     layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
@@ -162,7 +162,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(device);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -240,7 +240,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -267,14 +267,14 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
 {
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     device_data->imageMap.erase(image);
     device_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
@@ -352,7 +352,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -370,12 +370,12 @@
                << pCreateInfo->image << " that only has " << imageEntry->second.arraySize << " mip levels.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
         }
-        if (!pCreateInfo->subresourceRange.numLevels) {
+        if (!pCreateInfo->subresourceRange.levelCount) {
             std::stringstream ss;
             ss << "vkCreateImageView called with 0 in pCreateInfo->subresourceRange.mipLevels.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
         }
-        if (!pCreateInfo->subresourceRange.numLayers) {
+        if (!pCreateInfo->subresourceRange.layerCount) {
             std::stringstream ss;
             ss << "vkCreateImageView called with 0 in pCreateInfo->subresourceRange.arraySize.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
@@ -460,7 +460,7 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
-    VkCmdBuffer                    cmdBuffer,
+    VkCommandBuffer                commandBuffer,
     VkImage                        image,
     VkImageLayout                  imageLayout,
     const VkClearColorValue       *pColor,
@@ -468,24 +468,24 @@
     const VkImageSubresourceRange *pRanges)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // For each range, image aspect must be color only
     for (uint32_t i = 0; i < rangeCount; i++) {
         if (pRanges[i].aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) {
             char const str[] = "vkCmdClearColorImage aspectMasks for all subresource ranges must be set to VK_IMAGE_ASPECT_COLOR_BIT";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdClearColorImage(cmdBuffer, image, imageLayout,
-                                                                                  pColor, rangeCount, pRanges);
+        device_data->device_dispatch_table->CmdClearColorImage(commandBuffer, image, imageLayout,
+                                                               pColor, rangeCount, pRanges);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilImage(
-    VkCmdBuffer                     cmdBuffer,
+    VkCommandBuffer                 commandBuffer,
     VkImage                         image,
     VkImageLayout                   imageLayout,
     const VkClearDepthStencilValue *pDepthStencil,
@@ -493,7 +493,7 @@
     const VkImageSubresourceRange  *pRanges)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // For each range, Image aspect must be depth or stencil or both
     for (uint32_t i = 0; i < rangeCount; i++) {
         if (((pRanges[i].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT)   != VK_IMAGE_ASPECT_DEPTH_BIT) &&
@@ -502,102 +502,102 @@
             char const str[] = "vkCmdClearDepthStencilImage aspectMasks for all subresource ranges must be "
                                "set to VK_IMAGE_ASPECT_DEPTH_BIT and/or VK_IMAGE_ASPECT_STENCIL_BIT";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdClearDepthStencilImage(cmdBuffer,
+        device_data->device_dispatch_table->CmdClearDepthStencilImage(commandBuffer,
             image, imageLayout, pDepthStencil, rangeCount, pRanges);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
-    VkCmdBuffer        cmdBuffer,
+    VkCommandBuffer    commandBuffer,
     VkImage            srcImage,
     VkImageLayout      srcImageLayout,
-    VkImage            destImage,
-    VkImageLayout      destImageLayout,
+    VkImage            dstImage,
+    VkImageLayout      dstImageLayout,
     uint32_t           regionCount,
     const VkImageCopy *pRegions)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     auto srcImageEntry = device_data->imageMap.find(srcImage);
-    auto destImageEntry = device_data->imageMap.find(destImage);
+    auto dstImageEntry = device_data->imageMap.find(dstImage);
 
     // For each region, src and dst number of layers should not be zero
     // For each region, src and dst number of layers must match
     // For each region, src aspect mask must match dest aspect mask
     // For each region, color aspects cannot be mixed with depth/stencil aspects
     for (uint32_t i = 0; i < regionCount; i++) {
-        if(pRegions[i].srcSubresource.numLayers == 0)
+        if(pRegions[i].srcSubresource.layerCount == 0)
         {
             char const str[] = "vkCmdCopyImage: number of layers in source subresource is zero";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
-        if(pRegions[i].destSubresource.numLayers == 0)
+        if(pRegions[i].dstSubresource.layerCount == 0)
         {
             char const str[] = "vkCmdCopyImage: number of layers in destination subresource is zero";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
-        if(pRegions[i].srcSubresource.numLayers != pRegions[i].destSubresource.numLayers)
+        if(pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount)
         {
             char const str[] = "vkCmdCopyImage: number of layers in source and destination subresources must match";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
-        if (pRegions[i].srcSubresource.aspect != pRegions[i].destSubresource.aspect) {
+        if (pRegions[i].srcSubresource.aspect != pRegions[i].dstSubresource.aspect) {
             char const str[] = "vkCmdCopyImage: Src and dest aspectMasks for each region must match";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
         if ((pRegions[i].srcSubresource.aspect & VK_IMAGE_ASPECT_COLOR_BIT) &&
             (pRegions[i].srcSubresource.aspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) {
             char const str[] = "vkCmdCopyImage aspectMask cannot specify both COLOR and DEPTH/STENCIL aspects";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
     if ((srcImageEntry != device_data->imageMap.end())
-    && (destImageEntry != device_data->imageMap.end())) {
-        if (srcImageEntry->second.imageType != destImageEntry->second.imageType) {
+    && (dstImageEntry != device_data->imageMap.end())) {
+        if (srcImageEntry->second.imageType != dstImageEntry->second.imageType) {
             char const str[] = "vkCmdCopyImage called with unmatched source and dest image types.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
         }
         // Check that format is same size or exact stencil/depth
         if (is_depth_format(srcImageEntry->second.format)) {
-            if (srcImageEntry->second.format != destImageEntry->second.format) {
+            if (srcImageEntry->second.format != dstImageEntry->second.format) {
                 char const str[] = "vkCmdCopyImage called with unmatched source and dest image depth/stencil formats.";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                    (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
+                                    (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
             }
         } else {
             size_t srcSize = vk_format_get_size(srcImageEntry->second.format);
-            size_t destSize = vk_format_get_size(destImageEntry->second.format);
+            size_t destSize = vk_format_get_size(dstImageEntry->second.format);
             if (srcSize != destSize) {
                 char const str[] = "vkCmdCopyImage called with unmatched source and dest image format sizes.";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                    (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
+                                    (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
             }
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdCopyImage(cmdBuffer, srcImage,
-            srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+        device_data->device_dispatch_table->CmdCopyImage(commandBuffer, srcImage,
+            srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
     }
 }
 
 void VKAPI vkCmdClearAttachments(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                             commandBuffer,
     uint32_t                                    attachmentCount,
     const VkClearAttachment*                    pAttachments,
     uint32_t                                    rectCount,
@@ -605,7 +605,7 @@
 {
     VkBool32 skipCall = VK_FALSE;
     VkImageAspectFlags aspectMask;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     for (uint32_t i = 0; i < attachmentCount; i++) {
         aspectMask = pAttachments[i].aspectMask;
         if (aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
@@ -613,7 +613,7 @@
                 // VK_IMAGE_ASPECT_COLOR_BIT is not the only bit set for this attachment
                 char const str[] = "vkCmdClearAttachments aspectMask [%d] must set only VK_IMAGE_ASPECT_COLOR_BIT of a color attachment.";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
+                                (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
             }
         } else {
             // Image aspect must be depth or stencil or both
@@ -622,35 +622,35 @@
             {
                 char const str[] = "vkCmdClearAttachments aspectMask [%d] must be set to VK_IMAGE_ASPECT_DEPTH_BIT and/or VK_IMAGE_ASPECT_STENCIL_BIT";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                    (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
+                                    (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
             }
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdClearAttachments(cmdBuffer,
+        device_data->device_dispatch_table->CmdClearAttachments(commandBuffer,
             attachmentCount, pAttachments, rectCount, pRects);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(
-    VkCmdBuffer              cmdBuffer,
+    VkCommandBuffer          commandBuffer,
     VkImage                  srcImage,
     VkImageLayout            srcImageLayout,
-    VkBuffer                 destBuffer,
+    VkBuffer                 dstBuffer,
     uint32_t                 regionCount,
     const VkBufferImageCopy *pRegions)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // For each region, the number of layers in the image subresource should not be zero
     // Image aspect must be ONE OF color, depth, stencil
     for (uint32_t i = 0; i < regionCount; i++) {
-        if(pRegions[i].imageSubresource.numLayers == 0)
+        if(pRegions[i].imageSubresource.layerCount == 0)
         {
             char const str[] = "vkCmdCopyImageToBuffer: number of layers in image subresource is zero";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
         VkImageAspectFlags aspect = pRegions[i].imageSubresource.aspect;
@@ -659,34 +659,34 @@
             (aspect != VK_IMAGE_ASPECT_STENCIL_BIT)) {
             char const str[] = "vkCmdCopyImageToBuffer: aspectMasks for each region must specify only COLOR or DEPTH or STENCIL";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdCopyImageToBuffer(cmdBuffer,
-            srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+        device_data->device_dispatch_table->CmdCopyImageToBuffer(commandBuffer,
+            srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
-    VkCmdBuffer              cmdBuffer,
+    VkCommandBuffer          commandBuffer,
     VkBuffer                 srcBuffer,
-    VkImage                  destImage,
-    VkImageLayout            destImageLayout,
+    VkImage                  dstImage,
+    VkImageLayout            dstImageLayout,
     uint32_t                 regionCount,
     const VkBufferImageCopy *pRegions)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // For each region, the number of layers in the image subresource should not be zero
     // Image aspect must be ONE OF color, depth, stencil
     for (uint32_t i = 0; i < regionCount; i++) {
-        if(pRegions[i].imageSubresource.numLayers == 0)
+        if(pRegions[i].imageSubresource.layerCount == 0)
         {
             char const str[] = "vkCmdCopyBufferToImage: number of layers in image subresource is zero";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
         VkImageAspectFlags aspect = pRegions[i].imageSubresource.aspect;
@@ -695,47 +695,47 @@
             (aspect != VK_IMAGE_ASPECT_STENCIL_BIT)) {
             char const str[] = "vkCmdCopyBufferToImage: aspectMasks for each region must specify only COLOR or DEPTH or STENCIL";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdCopyBufferToImage(cmdBuffer,
-            srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+        device_data->device_dispatch_table->CmdCopyBufferToImage(commandBuffer,
+            srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(
-    VkCmdBuffer        cmdBuffer,
+    VkCommandBuffer    commandBuffer,
     VkImage            srcImage,
     VkImageLayout      srcImageLayout,
-    VkImage            destImage,
-    VkImageLayout      destImageLayout,
+    VkImage            dstImage,
+    VkImageLayout      dstImageLayout,
     uint32_t           regionCount,
     const VkImageBlit *pRegions,
     VkFilter        filter)
 {
     VkBool32    skipCall    = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
 
     auto srcImageEntry  = device_data->imageMap.find(srcImage);
-    auto destImageEntry = device_data->imageMap.find(destImage);
+    auto dstImageEntry = device_data->imageMap.find(dstImage);
 
     if ((srcImageEntry  != device_data->imageMap.end()) &&
-        (destImageEntry != device_data->imageMap.end())) {
+        (dstImageEntry != device_data->imageMap.end())) {
 
         VkFormat srcFormat = srcImageEntry->second.format;
-        VkFormat dstFormat = destImageEntry->second.format;
+        VkFormat dstFormat = dstImageEntry->second.format;
 
         // Validate consistency for signed and unsigned formats
         if ((vk_format_is_sint(srcFormat) && !vk_format_is_sint(dstFormat)) ||
             (vk_format_is_uint(srcFormat) && !vk_format_is_uint(dstFormat))) {
             std::stringstream ss;
-            ss << "vkCmdBlitImage: If one of srcImage and destImage images has signed/unsigned integer format, "
+            ss << "vkCmdBlitImage: If one of srcImage and dstImage images has signed/unsigned integer format, "
                << "the other one must also have signed/unsigned integer format.  "
                << "Source format is " << string_VkFormat(srcFormat) << " Destinatino format is " << string_VkFormat(dstFormat);
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                               (uint64_t)cmdBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
+                               (uint64_t)commandBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
         }
 
         // Validate aspect bits and formats for depth/stencil images
@@ -743,67 +743,67 @@
             vk_format_is_depth_or_stencil(dstFormat)) {
             if (srcFormat != dstFormat) {
                 std::stringstream ss;
-                ss << "vkCmdBlitImage: If one of srcImage and destImage images has a format of depth, stencil or depth "
+                ss << "vkCmdBlitImage: If one of srcImage and dstImage images has a format of depth, stencil or depth "
                    << "stencil, the other one must have exactly the same format.  "
                    << "Source format is " << string_VkFormat(srcFormat) << " Destinatino format is " << string_VkFormat(dstFormat);
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                   (uint64_t)cmdBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)commandBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
             }
 
             for (uint32_t i = 0; i < regionCount; i++) {
-                if(pRegions[i].srcSubresource.numLayers == 0)
+                if(pRegions[i].srcSubresource.layerCount == 0)
                 {
                     char const str[] = "vkCmdBlitImage: number of layers in source subresource is zero";
                     skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                        (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                                        (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
                 }
 
-                if(pRegions[i].destSubresource.numLayers == 0)
+                if(pRegions[i].dstSubresource.layerCount == 0)
                 {
                     char const str[] = "vkCmdBlitImage: number of layers in destination subresource is zero";
                     skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                        (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                                        (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
                 }
 
-                if(pRegions[i].srcSubresource.numLayers != pRegions[i].destSubresource.numLayers)
+                if(pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount)
                 {
                     char const str[] = "vkCmdBlitImage: number of layers in source and destination subresources must match";
                     skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                        (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                                        (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
                 }
 
                 VkImageAspectFlags srcAspect = pRegions[i].srcSubresource.aspect;
-                VkImageAspectFlags dstAspect = pRegions[i].destSubresource.aspect;
+                VkImageAspectFlags dstAspect = pRegions[i].dstSubresource.aspect;
 
                 if (srcAspect != dstAspect) {
                     std::stringstream ss;
                     ss << "vkCmdBlitImage: Image aspects of depth/stencil images should match";
                     skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                       (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                       (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
                 }
                 if (vk_format_is_depth_and_stencil(srcFormat)) {
                     if (srcAspect != (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
                         std::stringstream ss;
                         ss << "vkCmdBlitImage: Combination depth/stencil image formats must have both VK_IMAGE_ASPECT_DEPTH_BIT "
-                           << "and VK_IMAGE_ASPECT_STENCIL_BIT set in both the srcImage and destImage";
+                           << "and VK_IMAGE_ASPECT_STENCIL_BIT set in both the srcImage and dstImage";
                         skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                           (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                           (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
                     }
                 } else if (vk_format_is_stencil_only(srcFormat)) {
                     if (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT) {
                         std::stringstream ss;
                         ss << "vkCmdBlitImage: Stencil-only image formats must have only the VK_IMAGE_ASPECT_STENCIL_BIT "
-                           << "set in both the srcImage and destImage";
+                           << "set in both the srcImage and dstImage";
                         skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                           (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                           (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
                     }
                 } else if (vk_format_is_depth_only(srcFormat)) {
                     if (srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) {
                         std::stringstream ss;
                         ss << "vkCmdBlitImage: Depth-only image formats must have only the VK_IMAGE_ASPECT_DEPTH "
-                           << "set in both the srcImage and destImage";
+                           << "set in both the srcImage and dstImage";
                         skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                           (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                           (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
                     }
                 }
             }
@@ -817,81 +817,81 @@
                 ss << "vkCmdBlitImage: If the format of srcImage is a depth, stencil, depth stencil or integer-based format "
                    << "then filter must be VK_FILTER_NEAREST.";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                   (uint64_t)cmdBuffer, 0, IMAGE_INVALID_FILTER, "IMAGE", ss.str().c_str());
+                                   (uint64_t)commandBuffer, 0, IMAGE_INVALID_FILTER, "IMAGE", ss.str().c_str());
             }
         }
     }
 
-    device_data->device_dispatch_table->CmdBlitImage(cmdBuffer, srcImage,
-        srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+    device_data->device_dispatch_table->CmdBlitImage(commandBuffer, srcImage,
+        srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(
-    VkCmdBuffer           cmdBuffer,
+    VkCommandBuffer       commandBuffer,
     VkImage               srcImage,
     VkImageLayout         srcImageLayout,
-    VkImage               destImage,
-    VkImageLayout         destImageLayout,
+    VkImage               dstImage,
+    VkImageLayout         dstImageLayout,
     uint32_t              regionCount,
     const VkImageResolve *pRegions)
 {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     auto srcImageEntry = device_data->imageMap.find(srcImage);
-    auto destImageEntry = device_data->imageMap.find(destImage);
+    auto dstImageEntry = device_data->imageMap.find(dstImage);
 
     // For each region, the number of layers in the image subresource should not be zero
     // For each region, src and dest image aspect must be color only
     for (uint32_t i = 0; i < regionCount; i++) {
-        if(pRegions[i].srcSubresource.numLayers == 0)
+        if(pRegions[i].srcSubresource.layerCount == 0)
         {
             char const str[] = "vkCmdResolveImage: number of layers in source subresource is zero";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
-        if(pRegions[i].destSubresource.numLayers == 0)
+        if(pRegions[i].dstSubresource.layerCount == 0)
         {
             char const str[] = "vkCmdResolveImage: number of layers in destination subresource is zero";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
         if ((pRegions[i].srcSubresource.aspect  != VK_IMAGE_ASPECT_COLOR_BIT) ||
-            (pRegions[i].destSubresource.aspect != VK_IMAGE_ASPECT_COLOR_BIT)) {
+            (pRegions[i].dstSubresource.aspect != VK_IMAGE_ASPECT_COLOR_BIT)) {
             char const str[] = "vkCmdResolveImage: src and dest aspectMasks for each region must specify only VK_IMAGE_ASPECT_COLOR_BIT";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
     if ((srcImageEntry  != device_data->imageMap.end()) &&
-        (destImageEntry != device_data->imageMap.end())) {
-        if (srcImageEntry->second.format != destImageEntry->second.format) {
+        (dstImageEntry != device_data->imageMap.end())) {
+        if (srcImageEntry->second.format != dstImageEntry->second.format) {
             char const str[] =  "vkCmdResolveImage called with unmatched source and dest formats.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
         }
-        if (srcImageEntry->second.imageType != destImageEntry->second.imageType) {
+        if (srcImageEntry->second.imageType != dstImageEntry->second.imageType) {
             char const str[] =  "vkCmdResolveImage called with unmatched source and dest image types.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
         }
         if (srcImageEntry->second.samples <= 1) {
             char const str[] =  "vkCmdResolveImage called with source sample count less than 2.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_INVALID_RESOLVE_SAMPLES,  "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_INVALID_RESOLVE_SAMPLES,  "IMAGE", str);
         }
-        if (destImageEntry->second.samples > 1) {
+        if (dstImageEntry->second.samples > 1) {
             char const str[] =  "vkCmdResolveImage called with dest sample count greater than 1.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
-                                (uint64_t)cmdBuffer, 0, IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str);
+                                (uint64_t)commandBuffer, 0, IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str);
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdResolveImage(cmdBuffer, srcImage,
-            srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+        device_data->device_dispatch_table->CmdResolveImage(commandBuffer, srcImage,
+            srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
     }
 }
 
diff --git a/layers/image.h b/layers/image.h
index 868ecfe..dcfb81a 100644
--- a/layers/image.h
+++ b/layers/image.h
@@ -52,7 +52,7 @@
     uint32_t    samples;
     VkImageType imageType;
     VkExtent3D  extent;
-    _IMAGE_STATE():mipLevels(0), arraySize(0), format(VK_FORMAT_UNDEFINED), samples(0), imageType(VK_IMAGE_TYPE_NUM), extent{} {};
+    _IMAGE_STATE():mipLevels(0), arraySize(0), format(VK_FORMAT_UNDEFINED), samples(0), imageType(VK_IMAGE_TYPE_RANGE_SIZE), extent{} {};
     _IMAGE_STATE(const VkImageCreateInfo* pCreateInfo):
         mipLevels(pCreateInfo->mipLevels),
         arraySize(pCreateInfo->arrayLayers),
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 258e7e5..b2bd0eb 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -56,7 +56,7 @@
     bool wsi_enabled;
     uint64_t currentFenceId;
     // Maps for tracking key structs related to MemTracker state
-    unordered_map<VkCmdBuffer,    MT_CB_INFO>           cbMap;
+    unordered_map<VkCommandBuffer,    MT_CB_INFO>           cbMap;
     unordered_map<VkDeviceMemory, MT_MEM_OBJ_INFO>      memObjMap;
     unordered_map<VkFence,        MT_FENCE_INFO>        fenceMap;    // Map fence to fence info
     unordered_map<VkQueue,        MT_QUEUE_INFO>        queueMap;
@@ -136,14 +136,14 @@
 
 // Add new CBInfo for this cb to map container
 static void add_cmd_buf_info(layer_data* my_data,
-    const VkCmdBuffer cb)
+    const VkCommandBuffer cb)
 {
-    my_data->cbMap[cb].cmdBuffer = cb;
+    my_data->cbMap[cb].commandBuffer = cb;
 }
 
 // Return ptr to Info in CB map, or NULL if not found
 static MT_CB_INFO* get_cmd_buf_info(layer_data* my_data,
-    const VkCmdBuffer cb)
+    const VkCommandBuffer cb)
 {
     auto item = my_data->cbMap.find(cb);
     if (item != my_data->cbMap.end()) {
@@ -354,11 +354,11 @@
 static void add_mem_obj_info(layer_data* my_data,
     void*                    object,
     const VkDeviceMemory     mem,
-    const VkMemoryAllocInfo* pAllocInfo)
+    const VkMemoryAllocateInfo* pAllocateInfo)
 {
     assert(object != NULL);
 
-    memcpy(&my_data->memObjMap[mem].allocInfo, pAllocInfo, sizeof(VkMemoryAllocInfo));
+    memcpy(&my_data->memObjMap[mem].allocInfo, pAllocateInfo, sizeof(VkMemoryAllocateInfo));
     // TODO:  Update for real hardware, actually process allocation info structures
     my_data->memObjMap[mem].allocInfo.pNext = NULL;
     my_data->memObjMap[mem].object = object;
@@ -370,7 +370,7 @@
 // Find Mem Obj Info and add CB reference to list container
 static VkBool32 update_cmd_buf_and_mem_references(
     layer_data           *my_data,
-    const VkCmdBuffer     cb,
+    const VkCommandBuffer     cb,
     const VkDeviceMemory  mem,
     const char           *apiName)
 {
@@ -388,8 +388,8 @@
         } else {
             // Search for cmd buffer object in memory object's binding list
             VkBool32 found  = VK_FALSE;
-            if (pMemInfo->pCmdBufferBindings.size() > 0) {
-                for (list<VkCmdBuffer>::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) {
+            if (pMemInfo->pCommandBufferBindings.size() > 0) {
+                for (list<VkCommandBuffer>::iterator it = pMemInfo->pCommandBufferBindings.begin(); it != pMemInfo->pCommandBufferBindings.end(); ++it) {
                     if ((*it) == cb) {
                         found = VK_TRUE;
                         break;
@@ -398,7 +398,7 @@
             }
             // If not present, add to list
             if (found == VK_FALSE) {
-                pMemInfo->pCmdBufferBindings.push_front(cb);
+                pMemInfo->pCommandBufferBindings.push_front(cb);
                 pMemInfo->refCount++;
             }
             // Now update CBInfo's Mem reference list
@@ -430,7 +430,7 @@
 
 // Free bindings related to CB
 static VkBool32 clear_cmd_buf_and_mem_references(layer_data* my_data,
-    const VkCmdBuffer cb)
+    const VkCommandBuffer cb)
 {
     VkBool32 skipCall = VK_FALSE;
     MT_CB_INFO* pCBInfo = get_cmd_buf_info(my_data, cb);
@@ -442,7 +442,7 @@
             list<VkDeviceMemory> mem_obj_list = pCBInfo->pMemObjList;
             for (list<VkDeviceMemory>::iterator it=mem_obj_list.begin(); it!=mem_obj_list.end(); ++it) {
                 MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(my_data, *it);
-                pInfo->pCmdBufferBindings.remove(cb);
+                pInfo->pCommandBufferBindings.remove(cb);
                 pInfo->refCount--;
             }
         }
@@ -455,7 +455,7 @@
 static VkBool32 delete_cmd_buf_info_list(layer_data* my_data)
 {
     VkBool32 skipCall = VK_FALSE;
-    for (unordered_map<VkCmdBuffer, MT_CB_INFO>::iterator ii=my_data->cbMap.begin(); ii!=my_data->cbMap.end(); ++ii) {
+    for (unordered_map<VkCommandBuffer, MT_CB_INFO>::iterator ii=my_data->cbMap.begin(); ii!=my_data->cbMap.end(); ++ii) {
         skipCall |= clear_cmd_buf_and_mem_references(my_data, (*ii).first);
     }
     my_data->cbMap.clear();
@@ -467,23 +467,23 @@
     MT_MEM_OBJ_INFO* pMemObjInfo)
 {
     VkBool32 skipCall = VK_FALSE;
-    size_t cmdBufRefCount = pMemObjInfo->pCmdBufferBindings.size();
+    size_t cmdBufRefCount = pMemObjInfo->pCommandBufferBindings.size();
     size_t objRefCount    = pMemObjInfo->pObjBindings.size();
 
-    if ((pMemObjInfo->pCmdBufferBindings.size() + pMemObjInfo->pObjBindings.size()) != 0) {
+    if ((pMemObjInfo->pCommandBufferBindings.size() + pMemObjInfo->pObjBindings.size()) != 0) {
         skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) pMemObjInfo->mem, 0, MEMTRACK_FREED_MEM_REF, "MEM",
                        "Attempting to free memory object %#" PRIxLEAST64 " which still contains %lu references",
                        (uint64_t) pMemObjInfo->mem, (cmdBufRefCount + objRefCount));
     }
 
-    if (cmdBufRefCount > 0 && pMemObjInfo->pCmdBufferBindings.size() > 0) {
-        for (list<VkCmdBuffer>::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) {
-            // TODO : cmdBuffer should be source Obj here
+    if (cmdBufRefCount > 0 && pMemObjInfo->pCommandBufferBindings.size() > 0) {
+        for (list<VkCommandBuffer>::const_iterator it = pMemObjInfo->pCommandBufferBindings.begin(); it != pMemObjInfo->pCommandBufferBindings.end(); ++it) {
+            // TODO : CommandBuffer should be source Obj here
             log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)(*it), 0, MEMTRACK_FREED_MEM_REF, "MEM",
                     "Command Buffer %p still has a reference to mem obj %#" PRIxLEAST64, (*it), (uint64_t) pMemObjInfo->mem);
         }
         // Clear the list of hanging references
-        pMemObjInfo->pCmdBufferBindings.clear();
+        pMemObjInfo->pCommandBufferBindings.clear();
     }
 
     if (objRefCount > 0 && pMemObjInfo->pObjBindings.size() > 0) {
@@ -514,7 +514,7 @@
 
 // Check if fence for given CB is completed
 static VkBool32 checkCBCompleted(layer_data* my_data,
-    const VkCmdBuffer  cb,
+    const VkCommandBuffer  cb,
     VkBool32          *complete)
 {
     VkBool32 skipCall = VK_FALSE;
@@ -558,13 +558,13 @@
             // Clear any CB bindings for completed CBs
             //   TODO : Is there a better place to do this?
 
-            VkBool32 cmdBufferComplete = VK_FALSE;
+            VkBool32 commandBufferComplete = VK_FALSE;
             assert(pInfo->object != VK_NULL_HANDLE);
-            list<VkCmdBuffer>::iterator it = pInfo->pCmdBufferBindings.begin();
-            list<VkCmdBuffer>::iterator temp;
-            while (pInfo->pCmdBufferBindings.size() > 0 && it != pInfo->pCmdBufferBindings.end()) {
-                skipCall |= checkCBCompleted(my_data, *it, &cmdBufferComplete);
-                if (VK_TRUE == cmdBufferComplete) {
+            list<VkCommandBuffer>::iterator it = pInfo->pCommandBufferBindings.begin();
+            list<VkCommandBuffer>::iterator temp;
+            while (pInfo->pCommandBufferBindings.size() > 0 && it != pInfo->pCommandBufferBindings.end()) {
+                skipCall |= checkCBCompleted(my_data, *it, &commandBufferComplete);
+                if (VK_TRUE == commandBufferComplete) {
                     temp = it;
                     ++temp;
                     skipCall |= clear_cmd_buf_and_mem_references(my_data, *it);
@@ -825,7 +825,7 @@
         log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
                 "    Ref Count: %u", pInfo->refCount);
         if (0 != pInfo->allocInfo.allocationSize) {
-            string pAllocInfoMsg = vk_print_vkmemoryallocinfo(&pInfo->allocInfo, "MEM(INFO):         ");
+            string pAllocInfoMsg = vk_print_vkmemoryallocateinfo(&pInfo->allocInfo, "MEM(INFO):         ");
             log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
                     "    Mem Alloc info:\n%s", pAllocInfoMsg.c_str());
         } else {
@@ -843,10 +843,10 @@
         }
 
         log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
-                "    VK Command Buffer (CB) binding list of size %lu elements", pInfo->pCmdBufferBindings.size());
-        if (pInfo->pCmdBufferBindings.size() > 0)
+                "    VK Command Buffer (CB) binding list of size %lu elements", pInfo->pCommandBufferBindings.size());
+        if (pInfo->pCommandBufferBindings.size() > 0)
         {
-            for (list<VkCmdBuffer>::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) {
+            for (list<VkCommandBuffer>::iterator it = pInfo->pCommandBufferBindings.begin(); it != pInfo->pCommandBufferBindings.end(); ++it) {
                 log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
                         "      VK CB %p", (*it));
             }
@@ -877,7 +877,7 @@
 
         log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
                 "    CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %#" PRIxLEAST64,
-                (void*)pCBInfo, (void*)pCBInfo->cmdBuffer, pCBInfo->fenceId,
+                (void*)pCBInfo, (void*)pCBInfo->commandBuffer, pCBInfo->fenceId,
                 (uint64_t) pCBInfo->lastSubmittedFence);
 
         if (pCBInfo->pMemObjList.size() <= 0)
@@ -925,7 +925,7 @@
 }
 
 // hook DestroyInstance to remove tableInstanceMap entry
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
 {
     // Grab the key before the instance is destroyed.
     dispatch_key key = get_dispatch_key(instance);
@@ -952,7 +952,7 @@
 
 VkResult VKAPI vkCreateInstance(
     const VkInstanceCreateInfo*                 pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkInstance*                                 pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -994,7 +994,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice          gpu,
     const VkDeviceCreateInfo *pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkDevice                 *pDevice)
 {
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
@@ -1010,7 +1010,7 @@
 
 VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
     VkDevice device,
-    const VkAllocCallbacks* pAllocator)
+    const VkAllocationCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(device);
     layer_data *my_device_data = get_my_data_ptr(key, layer_data_map);
@@ -1195,17 +1195,17 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateMemory(
     VkDevice                 device,
-    const VkMemoryAllocInfo *pAllocInfo,
-    const VkAllocCallbacks* pAllocator,
-    VkDeviceMemory          *pMem)
+    const VkMemoryAllocateInfo *pAllocateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDeviceMemory          *pMemory)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = my_data->device_dispatch_table->AllocMemory(device, pAllocInfo, pAllocator, pMem);
+    VkResult result = my_data->device_dispatch_table->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
     // TODO : Track allocations and overall size here
     loader_platform_thread_lock_mutex(&globalLock);
-    add_mem_obj_info(my_data, device, *pMem, pAllocInfo);
+    add_mem_obj_info(my_data, device, *pMemory, pAllocateInfo);
     print_mem_list(my_data, device);
     loader_platform_thread_unlock_mutex(&globalLock);
     return result;
@@ -1214,7 +1214,7 @@
 VK_LAYER_EXPORT void VKAPI vkFreeMemory(
     VkDevice       device,
     VkDeviceMemory mem,
-    const VkAllocCallbacks* pAllocator)
+    const VkAllocationCallbacks* pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     /* From spec : A memory object is freed by calling vkFreeMemory() when it is no longer needed. Before
@@ -1265,7 +1265,7 @@
     my_data->device_dispatch_table->UnmapMemory(device, mem);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1278,7 +1278,7 @@
     my_data->device_dispatch_table->DestroyFence(device, fence, pAllocator);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
@@ -1294,7 +1294,7 @@
     }
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
@@ -1314,7 +1314,7 @@
     VkDevice                                    device,
     VkBuffer                                    buffer,
     VkDeviceMemory                              mem,
-    VkDeviceSize                                memOffset)
+    VkDeviceSize                                memoryOffset)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = VK_ERROR_VALIDATION_FAILED;
@@ -1325,7 +1325,7 @@
     print_mem_list(my_data, device);
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        result = my_data->device_dispatch_table->BindBufferMemory(device, buffer, mem, memOffset);
+        result = my_data->device_dispatch_table->BindBufferMemory(device, buffer, mem, memoryOffset);
     }
     return result;
 }
@@ -1334,7 +1334,7 @@
     VkDevice                                    device,
     VkImage                                     image,
     VkDeviceMemory                              mem,
-    VkDeviceSize                                memOffset)
+    VkDeviceSize                                memoryOffset)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = VK_ERROR_VALIDATION_FAILED;
@@ -1345,7 +1345,7 @@
     print_mem_list(my_data, device);
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        result = my_data->device_dispatch_table->BindImageMemory(device, image, mem, memOffset);
+        result = my_data->device_dispatch_table->BindImageMemory(device, image, mem, memoryOffset);
     }
     return result;
 }
@@ -1426,7 +1426,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
     VkDevice                 device,
     const VkFenceCreateInfo *pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkFence                 *pFence)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1566,7 +1566,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
     VkDevice                  device,
     const VkBufferCreateInfo *pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkBuffer                 *pBuffer)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1582,7 +1582,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
     VkDevice                 device,
     const VkImageCreateInfo *pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkImage                 *pImage)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1598,7 +1598,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
     VkDevice                     device,
     const VkImageViewCreateInfo *pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkImageView                 *pView)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1617,7 +1617,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
     VkDevice                      device,
     const VkBufferViewCreateInfo *pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkBufferView                 *pView)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1634,99 +1634,99 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateCommandBuffers(
     VkDevice                     device,
-    const VkCmdBufferAllocInfo *pCreateInfo,
-    VkCmdBuffer                 *pCmdBuffer)
+    const VkCommandBufferAllocateInfo *pCreateInfo,
+    VkCommandBuffer                 *pCommandBuffer)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = my_data->device_dispatch_table->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
+    VkResult result = my_data->device_dispatch_table->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
     // At time of cmd buffer creation, create global cmd buffer info for the returned cmd buffer
     loader_platform_thread_lock_mutex(&globalLock);
-    if (*pCmdBuffer)
-        add_cmd_buf_info(my_data, *pCmdBuffer);
+    if (*pCommandBuffer)
+        add_cmd_buf_info(my_data, *pCommandBuffer);
     printCBList(my_data, device);
     loader_platform_thread_unlock_mutex(&globalLock);
     return result;
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(
-    VkCmdBuffer                 cmdBuffer,
-    const VkCmdBufferBeginInfo *pBeginInfo)
+    VkCommandBuffer                 commandBuffer,
+    const VkCommandBufferBeginInfo *pBeginInfo)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkResult result            = VK_ERROR_VALIDATION_FAILED;
     VkBool32 skipCall          = VK_FALSE;
-    VkBool32 cmdBufferComplete = VK_FALSE;
+    VkBool32 commandBufferComplete = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
     // This implicitly resets the Cmd Buffer so make sure any fence is done and then clear memory references
-    skipCall = checkCBCompleted(my_data, cmdBuffer, &cmdBufferComplete);
+    skipCall = checkCBCompleted(my_data, commandBuffer, &commandBufferComplete);
 
-    if (VK_FALSE == cmdBufferComplete) {
-        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
+    if (VK_FALSE == commandBufferComplete) {
+        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
                         MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Calling vkBeginCommandBuffer() on active CB %p before it has completed. "
-                        "You must check CB flag before this call.", cmdBuffer);
+                        "You must check CB flag before this call.", commandBuffer);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        result = my_data->device_dispatch_table->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+        result = my_data->device_dispatch_table->BeginCommandBuffer(commandBuffer, pBeginInfo);
     }
     loader_platform_thread_lock_mutex(&globalLock);
-    clear_cmd_buf_and_mem_references(my_data, cmdBuffer);
+    clear_cmd_buf_and_mem_references(my_data, commandBuffer);
     loader_platform_thread_unlock_mutex(&globalLock);
     return result;
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(
-    VkCmdBuffer cmdBuffer)
+    VkCommandBuffer commandBuffer)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // TODO : Anything to do here?
-    VkResult result = my_data->device_dispatch_table->EndCommandBuffer(cmdBuffer);
+    VkResult result = my_data->device_dispatch_table->EndCommandBuffer(commandBuffer);
     return result;
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(
-    VkCmdBuffer cmdBuffer,
-    VkCmdBufferResetFlags flags)
+    VkCommandBuffer commandBuffer,
+    VkCommandBufferResetFlags flags)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkResult result            = VK_ERROR_VALIDATION_FAILED;
     VkBool32 skipCall          = VK_FALSE;
-    VkBool32 cmdBufferComplete = VK_FALSE;
+    VkBool32 commandBufferComplete = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
     // Verify that CB is complete (not in-flight)
-    skipCall = checkCBCompleted(my_data, cmdBuffer, &cmdBufferComplete);
-    if (VK_FALSE == cmdBufferComplete) {
-        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
+    skipCall = checkCBCompleted(my_data, commandBuffer, &commandBufferComplete);
+    if (VK_FALSE == commandBufferComplete) {
+        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
                         MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Resetting CB %p before it has completed. You must check CB "
-                        "flag before calling vkResetCommandBuffer().", cmdBuffer);
+                        "flag before calling vkResetCommandBuffer().", commandBuffer);
     }
     // Clear memory references as this point.
-    skipCall |= clear_cmd_buf_and_mem_references(my_data, cmdBuffer);
+    skipCall |= clear_cmd_buf_and_mem_references(my_data, commandBuffer);
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        result = my_data->device_dispatch_table->ResetCommandBuffer(cmdBuffer, flags);
+        result = my_data->device_dispatch_table->ResetCommandBuffer(commandBuffer, flags);
     }
     return result;
 }
 // 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 cmdBuffer
+//    need to account for that mem now having binding to given commandBuffer
 VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(
-    VkCmdBuffer         cmdBuffer,
+    VkCommandBuffer         commandBuffer,
     VkPipelineBindPoint pipelineBindPoint,
     VkPipeline          pipeline)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
 #if 0
-    // TODO : If memory bound to pipeline, then need to tie that mem to cmdBuffer
+    // TODO : If memory bound to pipeline, then need to tie that mem to commandBuffer
     if (getPipeline(pipeline)) {
-        MT_CB_INFO *pCBInfo = get_cmd_buf_info(my_data, cmdBuffer);
+        MT_CB_INFO *pCBInfo = get_cmd_buf_info(my_data, commandBuffer);
         if (pCBInfo) {
             pCBInfo->pipelines[pipelineBindPoint] = pipeline;
         } else {
-                    "Attempt to bind Pipeline %p to non-existant command buffer %p!", (void*)pipeline, cmdBuffer);
-            layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_INVALID_CB, (char *) "DS", (char *) str);
+                    "Attempt to bind Pipeline %p to non-existant command buffer %p!", (void*)pipeline, commandBuffer);
+            layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, commandBuffer, 0, MEMTRACK_INVALID_CB, (char *) "DS", (char *) str);
         }
     }
     else {
@@ -1734,179 +1734,179 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str);
     }
 #endif
-    my_data->device_dispatch_table->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+    my_data->device_dispatch_table->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     uint32_t                            viewportCount,
     const VkViewport*                   pViewports)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
     if (!pCmdBuf) {
-        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
-                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetViewport(cmdBuffer, viewportCount, pViewports);
+        my_data->device_dispatch_table->CmdSetViewport(commandBuffer, viewportCount, pViewports);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     uint32_t                            scissorCount,
     const VkRect2D*                     pScissors)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
     if (!pCmdBuf) {
-        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
-                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetScissor(cmdBuffer, scissorCount, pScissors);
+        my_data->device_dispatch_table->CmdSetScissor(commandBuffer, scissorCount, pScissors);
     }
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth)
+VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
     if (!pCmdBuf) {
-        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
-                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetLineWidth(cmdBuffer, lineWidth);
+        my_data->device_dispatch_table->CmdSetLineWidth(commandBuffer, lineWidth);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBias(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     float                               depthBiasConstantFactor,
     float                               depthBiasClamp,
     float                               depthBiasSlopeFactor)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
     if (!pCmdBuf) {
-        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
-                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetDepthBias(cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+        my_data->device_dispatch_table->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(
-     VkCmdBuffer                            cmdBuffer,
+     VkCommandBuffer                            commandBuffer,
      const float                            blendConstants[4])
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
     if (!pCmdBuf) {
-        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
-                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetBlendConstants(cmdBuffer, blendConstants);
+        my_data->device_dispatch_table->CmdSetBlendConstants(commandBuffer, blendConstants);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBounds(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     float                               minDepthBounds,
     float                               maxDepthBounds)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
     if (!pCmdBuf) {
-        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
-                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds);
+        my_data->device_dispatch_table->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     VkStencilFaceFlags                  faceMask,
     uint32_t                            stencilCompareMask)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
     if (!pCmdBuf) {
-        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
-                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask);
+        my_data->device_dispatch_table->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     VkStencilFaceFlags                  faceMask,
     uint32_t                            stencilWriteMask)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
     if (!pCmdBuf) {
-        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
-                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask);
+        my_data->device_dispatch_table->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     VkStencilFaceFlags                  faceMask,
     uint32_t                            stencilReference)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, cmdBuffer);
+    MT_CB_INFO *pCmdBuf = get_cmd_buf_info(my_data, commandBuffer);
     if (!pCmdBuf) {
-        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cmdBuffer, 0,
-                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
+        skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0,
+                       MEMTRACK_INVALID_CB, "MEM", "Unable to find command buffer object %p, was it ever created?", (void*)commandBuffer);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
+        my_data->device_dispatch_table->CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
-    VkCmdBuffer            cmdBuffer,
+    VkCommandBuffer            commandBuffer,
     VkPipelineBindPoint    pipelineBindPoint,
     VkPipelineLayout       layout,
     uint32_t               firstSet,
@@ -1915,378 +1915,378 @@
     uint32_t               dynamicOffsetCount,
     const uint32_t        *pDynamicOffsets)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state
     my_data->device_dispatch_table->CmdBindDescriptorSets(
-        cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+        commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
-    VkCmdBuffer         cmdBuffer,
+    VkCommandBuffer         commandBuffer,
     uint32_t            startBinding,
     uint32_t            bindingCount,
     const VkBuffer     *pBuffers,
     const VkDeviceSize *pOffsets)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // TODO : Somewhere need to verify that VBs have correct usage state flagged
-    my_data->device_dispatch_table->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+    my_data->device_dispatch_table->CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(
-    VkCmdBuffer  cmdBuffer,
+    VkCommandBuffer  commandBuffer,
     VkBuffer     buffer,
     VkDeviceSize offset,
     VkIndexType  indexType)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // TODO : Somewhere need to verify that IBs have correct usage state flagged
-    my_data->device_dispatch_table->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+    my_data->device_dispatch_table->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(
-    VkCmdBuffer   cmdBuffer,
+    VkCommandBuffer   commandBuffer,
      VkBuffer     buffer,
      VkDeviceSize offset,
      uint32_t     count,
      uint32_t     stride)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
     loader_platform_thread_lock_mutex(&globalLock);
-    VkBool32 skipCall  = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
-    skipCall          |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdDrawIndirect");
+    VkBool32 skipCall  = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall          |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdDrawIndirect");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+        my_data->device_dispatch_table->CmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
-    VkCmdBuffer  cmdBuffer,
+    VkCommandBuffer  commandBuffer,
     VkBuffer     buffer,
     VkDeviceSize offset,
     uint32_t     count,
     uint32_t     stride)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
     loader_platform_thread_lock_mutex(&globalLock);
-    VkBool32 skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
-    skipCall         |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdDrawIndexedIndirect");
+    VkBool32 skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall         |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdDrawIndexedIndirect");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+        my_data->device_dispatch_table->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(
-    VkCmdBuffer  cmdBuffer,
+    VkCommandBuffer  commandBuffer,
     VkBuffer     buffer,
     VkDeviceSize offset)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
     loader_platform_thread_lock_mutex(&globalLock);
-    VkBool32 skipCall = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
-    skipCall         |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdDispatchIndirect");
+    VkBool32 skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall         |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdDispatchIndirect");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdDispatchIndirect(cmdBuffer, buffer, offset);
+        my_data->device_dispatch_table->CmdDispatchIndirect(commandBuffer, buffer, offset);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(
-    VkCmdBuffer         cmdBuffer,
+    VkCommandBuffer     commandBuffer,
     VkBuffer            srcBuffer,
-    VkBuffer            destBuffer,
+    VkBuffer            dstBuffer,
     uint32_t            regionCount,
     const VkBufferCopy *pRegions)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyBuffer");
-    skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyBuffer");
+    skipCall  = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBuffer");
+    skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBuffer");
     // Validate that SRC & DST buffers have correct usage flags set
-    skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT");
-    skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+    skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
+    skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+        my_data->device_dispatch_table->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                             commandBuffer,
     VkQueryPool                                 queryPool,
     uint32_t                                    startQuery,
     uint32_t                                    queryCount,
-    VkBuffer                                    destBuffer,
-    VkDeviceSize                                destOffset,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
     VkDeviceSize                                destStride,
     VkQueryResultFlags                          flags)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyQueryPoolResults");
+    skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyQueryPoolResults");
     // Validate that DST buffer has correct usage flags set
-    skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyQueryPoolResults()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+    skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyQueryPoolResults()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
+        my_data->device_dispatch_table->CmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, destStride, flags);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
-    VkCmdBuffer        cmdBuffer,
+    VkCommandBuffer    commandBuffer,
     VkImage            srcImage,
     VkImageLayout      srcImageLayout,
-    VkImage            destImage,
-    VkImageLayout      destImageLayout,
+    VkImage            dstImage,
+    VkImageLayout      dstImageLayout,
     uint32_t           regionCount,
     const VkImageCopy *pRegions)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
     // Validate that src & dst images have correct usage flags set
-    skipCall  = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyImage");
-    skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destImage, VK_OBJECT_TYPE_IMAGE, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyImage");
-    skipCall |= validate_image_usage_flags(my_data, cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
-    skipCall |= validate_image_usage_flags(my_data, cmdBuffer, destImage, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
+    skipCall  = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImage");
+    skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImage");
+    skipCall |= validate_image_usage_flags(my_data, commandBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
+    skipCall |= validate_image_usage_flags(my_data, commandBuffer, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
         my_data->device_dispatch_table->CmdCopyImage(
-            cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+            commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(
-    VkCmdBuffer        cmdBuffer,
+    VkCommandBuffer        commandBuffer,
     VkImage            srcImage,
     VkImageLayout      srcImageLayout,
-    VkImage            destImage,
-    VkImageLayout      destImageLayout,
+    VkImage            dstImage,
+    VkImageLayout      dstImageLayout,
     uint32_t           regionCount,
     const VkImageBlit *pRegions,
     VkFilter        filter)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
     // Validate that src & dst images have correct usage flags set
-    skipCall  = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdBlitImage");
-    skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destImage, VK_OBJECT_TYPE_IMAGE, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdBlitImage");
-    skipCall |= validate_image_usage_flags(my_data, cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
-    skipCall |= validate_image_usage_flags(my_data, cmdBuffer, destImage, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
+    skipCall  = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdBlitImage");
+    skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdBlitImage");
+    skipCall |= validate_image_usage_flags(my_data, commandBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
+    skipCall |= validate_image_usage_flags(my_data, commandBuffer, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
         my_data->device_dispatch_table->CmdBlitImage(
-            cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+            commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
-    VkCmdBuffer              cmdBuffer,
+    VkCommandBuffer              commandBuffer,
     VkBuffer                 srcBuffer,
-    VkImage                  destImage,
-    VkImageLayout            destImageLayout,
+    VkImage                  dstImage,
+    VkImageLayout            dstImageLayout,
     uint32_t                 regionCount,
     const VkBufferImageCopy *pRegions)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destImage, VK_OBJECT_TYPE_IMAGE, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyBufferToImage");
-    skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyBufferToImage");
+    skipCall  = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBufferToImage");
+    skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBufferToImage");
     // Validate that src buff & dst image have correct usage flags set
-    skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyBufferToImage()", "VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT");
-    skipCall |= validate_image_usage_flags(my_data, cmdBuffer, destImage, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyBufferToImage()", "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
+    skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyBufferToImage()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
+    skipCall |= validate_image_usage_flags(my_data, commandBuffer, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyBufferToImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
         my_data->device_dispatch_table->CmdCopyBufferToImage(
-        cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+        commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(
-    VkCmdBuffer              cmdBuffer,
+    VkCommandBuffer              commandBuffer,
     VkImage                  srcImage,
     VkImageLayout            srcImageLayout,
-    VkBuffer                 destBuffer,
+    VkBuffer                 dstBuffer,
     uint32_t                 regionCount,
     const VkBufferImageCopy *pRegions)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyImageToBuffer");
-    skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdCopyImageToBuffer");
+    skipCall  = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImageToBuffer");
+    skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImageToBuffer");
     // Validate that dst buff & src image have correct usage flags set
-    skipCall |= validate_image_usage_flags(my_data, cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyImageToBuffer()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
-    skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyImageToBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+    skipCall |= validate_image_usage_flags(my_data, commandBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyImageToBuffer()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
+    skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyImageToBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
         my_data->device_dispatch_table->CmdCopyImageToBuffer(
-            cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+            commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(
-    VkCmdBuffer     cmdBuffer,
-    VkBuffer        destBuffer,
-    VkDeviceSize    destOffset,
+    VkCommandBuffer     commandBuffer,
+    VkBuffer        dstBuffer,
+    VkDeviceSize    dstOffset,
     VkDeviceSize    dataSize,
     const uint32_t *pData)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdUpdateBuffer");
+    skipCall  = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdUpdateBuffer");
     // Validate that dst buff has correct usage flags set
-    skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdUpdateBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+    skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdUpdateBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+        my_data->device_dispatch_table->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
-    VkCmdBuffer  cmdBuffer,
-    VkBuffer     destBuffer,
-    VkDeviceSize destOffset,
+    VkCommandBuffer  commandBuffer,
+    VkBuffer     dstBuffer,
+    VkDeviceSize dstOffset,
     VkDeviceSize size,
     uint32_t     data)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdFillBuffer");
+    skipCall  = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdFillBuffer");
     // Validate that dst buff has correct usage flags set
-    skipCall |= validate_buffer_usage_flags(my_data, cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdFillBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+    skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdFillBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+        my_data->device_dispatch_table->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
-    VkCmdBuffer                    cmdBuffer,
+    VkCommandBuffer                    commandBuffer,
     VkImage                        image,
     VkImageLayout                  imageLayout,
     const VkClearColorValue       *pColor,
     uint32_t                       rangeCount,
     const VkImageSubresourceRange *pRanges)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)image, VK_OBJECT_TYPE_IMAGE, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdClearColorImage");
+    skipCall  = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)image, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdClearColorImage");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+        my_data->device_dispatch_table->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilImage(
-    VkCmdBuffer                         cmdBuffer,
+    VkCommandBuffer                         commandBuffer,
     VkImage                             image,
     VkImageLayout                       imageLayout,
     const VkClearDepthStencilValue*     pDepthStencil,
     uint32_t                            rangeCount,
     const VkImageSubresourceRange*      pRanges)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)image, VK_OBJECT_TYPE_IMAGE, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdClearDepthStencilImage");
+    skipCall  = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)image, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdClearDepthStencilImage");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
         my_data->device_dispatch_table->CmdClearDepthStencilImage(
-            cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+            commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(
-    VkCmdBuffer           cmdBuffer,
+    VkCommandBuffer           commandBuffer,
     VkImage               srcImage,
     VkImageLayout         srcImageLayout,
-    VkImage               destImage,
-    VkImageLayout         destImageLayout,
+    VkImage               dstImage,
+    VkImageLayout         dstImageLayout,
     uint32_t              regionCount,
     const VkImageResolve *pRegions)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem;
-    skipCall  = get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdResolveImage");
-    skipCall |= get_mem_binding_from_object(my_data, cmdBuffer, (uint64_t)destImage, VK_OBJECT_TYPE_IMAGE, &mem);
-    skipCall |= update_cmd_buf_and_mem_references(my_data, cmdBuffer, mem, "vkCmdResolveImage");
+    skipCall  = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdResolveImage");
+    skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdResolveImage");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
         my_data->device_dispatch_table->CmdResolveImage(
-            cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+            commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
     }
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkQueryPool queryPool,
     uint32_t    slot,
     VkFlags     flags)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    my_data->device_dispatch_table->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    my_data->device_dispatch_table->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkQueryPool queryPool,
     uint32_t    slot)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    my_data->device_dispatch_table->CmdEndQuery(cmdBuffer, queryPool, slot);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    my_data->device_dispatch_table->CmdEndQuery(commandBuffer, queryPool, slot);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkQueryPool queryPool,
     uint32_t    startQuery,
     uint32_t    queryCount)
 {
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    my_data->device_dispatch_table->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+    layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    my_data->device_dispatch_table->CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
@@ -2433,7 +2433,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(
     VkDevice                     device,
     const VkSemaphoreCreateInfo *pCreateInfo,
-    const VkAllocCallbacks*      pAllocator,
+    const VkAllocationCallbacks*      pAllocator,
     VkSemaphore                 *pSemaphore)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -2449,7 +2449,7 @@
 VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(
     VkDevice    device,
     VkSemaphore semaphore,
-    const VkAllocCallbacks* pAllocator)
+    const VkAllocationCallbacks* pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     loader_platform_thread_lock_mutex(&globalLock);
@@ -2483,8 +2483,8 @@
         return (PFN_vkVoidFunction) vkDestroyDevice;
     if (!strcmp(funcName, "vkQueueSubmit"))
         return (PFN_vkVoidFunction) vkQueueSubmit;
-    if (!strcmp(funcName, "vkAllocMemory"))
-        return (PFN_vkVoidFunction) vkAllocMemory;
+    if (!strcmp(funcName, "vkAllocateMemory"))
+        return (PFN_vkVoidFunction) vkAllocateMemory;
     if (!strcmp(funcName, "vkFreeMemory"))
         return (PFN_vkVoidFunction) vkFreeMemory;
     if (!strcmp(funcName, "vkMapMemory"))
@@ -2531,8 +2531,8 @@
         return (PFN_vkVoidFunction) vkCreateImageView;
     if (!strcmp(funcName, "vkCreateBufferView"))
         return (PFN_vkVoidFunction) vkCreateBufferView;
-    if (!strcmp(funcName, "vkAllocCommandBuffers"))
-        return (PFN_vkVoidFunction) vkAllocCommandBuffers;
+    if (!strcmp(funcName, "vkAllocateCommandBuffers"))
+        return (PFN_vkVoidFunction) vkAllocateCommandBuffers;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
         return (PFN_vkVoidFunction) vkBeginCommandBuffer;
     if (!strcmp(funcName, "vkEndCommandBuffer"))
diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h
index b09c247..b638ce4 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -99,9 +99,9 @@
     void*                       object;             // Dispatchable object used to create this memory (device of swapchain)
     uint32_t                    refCount;           // Count of references (obj bindings or CB use)
     VkDeviceMemory              mem;
-    VkMemoryAllocInfo           allocInfo;
+    VkMemoryAllocateInfo           allocInfo;
     list<MT_OBJ_HANDLE_TYPE>    pObjBindings;       // list container of objects bound to this memory
-    list<VkCmdBuffer>           pCmdBufferBindings; // list container of cmd buffers that reference this mem object
+    list<VkCommandBuffer>           pCommandBufferBindings; // list container of cmd buffers that reference this mem object
 };
 
 // This only applies to Buffers and Images, which can have memory bound to them
@@ -115,10 +115,10 @@
 
 // Track all command buffers
 typedef struct _MT_CB_INFO {
-    VkCmdBufferAllocInfo        createInfo;
-    VkPipeline                  pipelines[VK_PIPELINE_BIND_POINT_NUM];
+    VkCommandBufferAllocateInfo       createInfo;
+    VkPipeline                  pipelines[VK_PIPELINE_BIND_POINT_RANGE_SIZE];
     uint32_t                    attachmentCount;
-    VkCmdBuffer                 cmdBuffer;
+    VkCommandBuffer                 commandBuffer;
     uint64_t                    fenceId;
     VkFence                     lastSubmittedFence;
     VkQueue                     lastSubmittedQueue;
@@ -139,7 +139,7 @@
 struct MT_QUEUE_INFO {
     uint64_t                    lastRetiredId;
     uint64_t                    lastSubmittedId;
-    list<VkCmdBuffer>           pQueueCmdBuffers;
+    list<VkCommandBuffer>           pQueueCommandBuffers;
     list<VkDeviceMemory>        pMemRefList;
 };
 
diff --git a/layers/multi.cpp b/layers/multi.cpp
index 5234462..14cb954 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -40,7 +40,7 @@
 /******************************** Layer multi1 functions **************************/
 
 /* hook DestroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI multi1DestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI multi1DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
 {
     VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
     dispatch_key key = get_dispatch_key(device);
@@ -51,7 +51,7 @@
     printf("Completed multi1 layer vkDestroyDevice()\n");
 }
 
-VK_LAYER_EXPORT VkResult VKAPI multi1CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler)
+VK_LAYER_EXPORT VkResult VKAPI multi1CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
 {
     VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
 
@@ -66,7 +66,7 @@
                                 VkPipelineCache pipelineCache,
                                 uint32_t count,
                                 const VkGraphicsPipelineCreateInfo* pCreateInfos,
-                                const VkAllocCallbacks* pAllocator,
+                                const VkAllocationCallbacks* pAllocator,
                                 VkPipeline* pPipelines)
 {
     VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
@@ -140,7 +140,7 @@
 }
 
 /* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI multi2DestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI multi2DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
 {
     VkLayerInstanceDispatchTable *pDisp = get_dispatch_table(multi2_instance_table_map, instance);
     dispatch_key key = get_dispatch_key(instance);
diff --git a/layers/object_track.h b/layers/object_track.h
index f3a1252..4982b87 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -115,8 +115,8 @@
 {
     switch ((VkDbgObjectType)input_value)
     {
-        case VK_OBJECT_TYPE_CMD_POOL:
-            return "VK_OBJECT_TYPE_CMD_POOL";
+        case VK_OBJECT_TYPE_COMMAND_POOL:
+            return "VK_OBJECT_TYPE_COMMAND_POOL";
         case VK_OBJECT_TYPE_BUFFER:
             return "VK_OBJECT_TYPE_BUFFER";
         case VK_OBJECT_TYPE_BUFFER_VIEW:
@@ -422,9 +422,9 @@
 static void create_obj(VkDevice dispatchable_object, VkDescriptorSet object, VkDbgObjectType objType);
 static void create_obj(VkDevice dispatchable_object, VkQueue vkObj, VkDbgObjectType objType);
 static VkBool32 validate_object(VkQueue dispatchable_object, VkImage object);
-static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkImage object);
-static VkBool32 validate_object(VkQueue dispatchable_object, VkCmdBuffer object);
-static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkDescriptorSet object);
+static VkBool32 validate_object(VkCommandBuffer dispatchable_object, VkImage object);
+static VkBool32 validate_object(VkQueue dispatchable_object, VkCommandBuffer object);
+static VkBool32 validate_object(VkCommandBuffer dispatchable_object, VkDescriptorSet object);
 static VkBool32 validate_object(VkInstance dispatchable_object, VkInstance object);
 static VkBool32 validate_object(VkDevice dispatchable_object, VkDevice object);
 static VkBool32 validate_object(VkDevice dispatchable_object, VkDescriptorPool object);
@@ -446,7 +446,7 @@
 extern unordered_map<const void*, OBJTRACK_NODE*> VkBufferMap;
 extern unordered_map<const void*, OBJTRACK_NODE*> VkFenceMap;
 extern unordered_map<const void*, OBJTRACK_NODE*> VkSemaphoreMap;
-extern unordered_map<const void*, OBJTRACK_NODE*> VkCmdBufferMap;
+extern unordered_map<const void*, OBJTRACK_NODE*> VkCommandBufferMap;
 extern unordered_map<const void*, OBJTRACK_NODE*> VkSwapchainKHRMap;
 
 static VkBool32 validate_object(VkQueue dispatchable_object, VkImage object)
@@ -459,7 +459,7 @@
     return VK_FALSE;
 }
 
-static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkImage object)
+static VkBool32 validate_object(VkCommandBuffer dispatchable_object, VkImage object)
 {
     if ((VkImageMap.find((void*)object)        == VkImageMap.end()) &&
         (swapchainImageMap.find((void*)object) == swapchainImageMap.end())) {
@@ -469,16 +469,16 @@
     return VK_FALSE;
 }
 
-static VkBool32 validate_object(VkQueue dispatchable_object, VkCmdBuffer object)
+static VkBool32 validate_object(VkQueue dispatchable_object, VkCommandBuffer object)
 {
-    if (VkCmdBufferMap.find(object) == VkCmdBufferMap.end()) {
+    if (VkCommandBufferMap.find(object) == VkCommandBufferMap.end()) {
         return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
-            "Invalid VkCmdBuffer Object %p",reinterpret_cast<uint64_t>(object));
+            "Invalid VkCommandBuffer Object %p",reinterpret_cast<uint64_t>(object));
     }
     return VK_FALSE;
 }
 
-static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkDescriptorSet object)
+static VkBool32 validate_object(VkCommandBuffer dispatchable_object, VkDescriptorSet object)
 {
     if (VkDescriptorSetMap.find((void*)object) == VkDescriptorSetMap.end()) {
         return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
@@ -523,11 +523,11 @@
     return VK_FALSE;
 }
 
-static VkBool32 validate_object(VkDevice dispatchable_object, VkCmdBuffer object)
+static VkBool32 validate_object(VkDevice dispatchable_object, VkCommandBuffer object)
 {
-    if (VkCmdBufferMap.find(object) == VkCmdBufferMap.end()) {
+    if (VkCommandBufferMap.find(object) == VkCommandBufferMap.end()) {
         return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
-            "Invalid VkCmdBuffer Object %p",reinterpret_cast<uint64_t>(object));
+            "Invalid VkCommandBuffer Object %p",reinterpret_cast<uint64_t>(object));
     }
     return VK_FALSE;
 }
@@ -548,7 +548,7 @@
     numTotalObjs++;
 }
 
-static void create_obj(VkDevice dispatchable_object, VkCmdBuffer vkObj, VkDbgObjectType objType)
+static void create_obj(VkDevice dispatchable_object, VkCommandBuffer vkObj, VkDbgObjectType objType)
 {
     log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast<uint64_t>(vkObj), 0, OBJTRACK_NONE, "OBJTRACK",
         "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),
@@ -558,7 +558,7 @@
     pNewObjNode->objType = objType;
     pNewObjNode->status  = OBJSTATUS_NONE;
     pNewObjNode->vkObj  = reinterpret_cast<uint64_t>(vkObj);
-    VkCmdBufferMap[vkObj] = pNewObjNode;
+    VkCommandBufferMap[vkObj] = pNewObjNode;
     uint32_t objIndex = objTypeToIndex(objType);
     numObjs[objIndex]++;
     numTotalObjs++;
@@ -634,7 +634,7 @@
 VkResult
 explicit_CreateInstance(
     const VkInstanceCreateInfo *pCreateInfo,
-    const VkAllocCallbacks     * pAllocator,
+    const VkAllocationCallbacks     * pAllocator,
     VkInstance                 * pInstance)
 {
 
@@ -674,7 +674,7 @@
 explicit_CreateDevice(
     VkPhysicalDevice         gpu,
     const VkDeviceCreateInfo *pCreateInfo,
-    const VkAllocCallbacks   *pAllocator,
+    const VkAllocationCallbacks   *pAllocator,
     VkDevice                 *pDevice)
 {
     loader_platform_thread_lock_mutex(&objLock);
@@ -798,27 +798,27 @@
 }
 
 VkResult
-explicit_AllocDescriptorSets(
+explicit_AllocateDescriptorSets(
     VkDevice                     device,
-    const VkDescriptorSetAllocInfo *pAllocInfo,
+    const VkDescriptorSetAllocateInfo *pAllocateInfo,
     VkDescriptorSet             *pDescriptorSets)
 {
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&objLock);
     skipCall |= validate_object(device, device);
-    skipCall |= validate_object(device, pAllocInfo->descriptorPool);
-    for (uint32_t i = 0; i < pAllocInfo->setLayoutCount; i++) {
-        skipCall |= validate_object(device, pAllocInfo->pSetLayouts[i]);
+    skipCall |= validate_object(device, pAllocateInfo->descriptorPool);
+    for (uint32_t i = 0; i < pAllocateInfo->setLayoutCount; i++) {
+        skipCall |= validate_object(device, pAllocateInfo->pSetLayouts[i]);
     }
     loader_platform_thread_unlock_mutex(&objLock);
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED;
 
-    VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->AllocDescriptorSets(
-        device, pAllocInfo, pDescriptorSets);
+    VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->AllocateDescriptorSets(
+        device, pAllocateInfo, pDescriptorSets);
 
     loader_platform_thread_lock_mutex(&objLock);
-    for (uint32_t i = 0; i < pAllocInfo->setLayoutCount; i++) {
+    for (uint32_t i = 0; i < pAllocateInfo->setLayoutCount; i++) {
         create_obj(device, pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);
     }
     loader_platform_thread_unlock_mutex(&objLock);
@@ -854,7 +854,7 @@
 explicit_FreeMemory(
     VkDevice       device,
     VkDeviceMemory mem,
-    const VkAllocCallbacks* pAllocator)
+    const VkAllocationCallbacks* pAllocator)
 {
     loader_platform_thread_lock_mutex(&objLock);
     validate_object(device, device);
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 2181e44..ce64cf4 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -287,8 +287,8 @@
         VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT |
         VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
         VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT |
-        VK_FORMAT_FEATURE_BLIT_SOURCE_BIT |
-        VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT);
+        VK_FORMAT_FEATURE_BLIT_SRC_BIT |
+        VK_FORMAT_FEATURE_BLIT_DST_BIT);
     if(enumerator & (~allFlags))
     {
         return false;
@@ -346,13 +346,13 @@
     {
         strings.push_back("VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_BLIT_SOURCE_BIT)
+    if(enumerator & VK_FORMAT_FEATURE_BLIT_SRC_BIT)
     {
-        strings.push_back("VK_FORMAT_FEATURE_BLIT_SOURCE_BIT");
+        strings.push_back("VK_FORMAT_FEATURE_BLIT_SRC_BIT");
     }
-    if(enumerator & VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT)
+    if(enumerator & VK_FORMAT_FEATURE_BLIT_DST_BIT)
     {
-        strings.push_back("VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT");
+        strings.push_back("VK_FORMAT_FEATURE_BLIT_DST_BIT");
     }
 
     std::string enumeratorString;
@@ -377,9 +377,9 @@
         VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
         VK_IMAGE_USAGE_STORAGE_BIT |
         VK_IMAGE_USAGE_SAMPLED_BIT |
-        VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT |
+        VK_IMAGE_USAGE_TRANSFER_DST_BIT |
         VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT |
-        VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT);
+        VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
     if(enumerator & (~allFlags))
     {
         return false;
@@ -417,17 +417,17 @@
     {
         strings.push_back("VK_IMAGE_USAGE_SAMPLED_BIT");
     }
-    if(enumerator & VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT)
+    if(enumerator & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
     {
-        strings.push_back("VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
+        strings.push_back("VK_IMAGE_USAGE_TRANSFER_DST_BIT");
     }
     if(enumerator & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT)
     {
         strings.push_back("VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT");
     }
-    if(enumerator & VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT)
+    if(enumerator & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)
     {
-        strings.push_back("VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
+        strings.push_back("VK_IMAGE_USAGE_TRANSFER_SRC_BIT");
     }
 
     std::string enumeratorString;
@@ -888,9 +888,9 @@
         VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT |
         VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT |
         VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
-        VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT |
+        VK_BUFFER_USAGE_TRANSFER_DST_BIT |
         VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
-        VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT |
+        VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
         VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
     if(enumerator & (~allFlags))
     {
@@ -929,17 +929,17 @@
     {
         strings.push_back("VK_BUFFER_USAGE_STORAGE_BUFFER_BIT");
     }
-    if(enumerator & VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT)
+    if(enumerator & VK_BUFFER_USAGE_TRANSFER_DST_BIT)
     {
-        strings.push_back("VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
+        strings.push_back("VK_BUFFER_USAGE_TRANSFER_DST_BIT");
     }
     if(enumerator & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT)
     {
         strings.push_back("VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT");
     }
-    if(enumerator & VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT)
+    if(enumerator & VK_BUFFER_USAGE_TRANSFER_SRC_BIT)
     {
-        strings.push_back("VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT");
+        strings.push_back("VK_BUFFER_USAGE_TRANSFER_SRC_BIT");
     }
     if(enumerator & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
     {
@@ -1506,10 +1506,10 @@
 }
 
 static
-bool ValidateEnumerator(VkCmdPoolCreateFlagBits const& enumerator)
+bool ValidateEnumerator(VkCommandPoolCreateFlagBits const& enumerator)
 {
-    VkCmdPoolCreateFlagBits allFlags = (VkCmdPoolCreateFlagBits)(VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT |
-        VK_CMD_POOL_CREATE_TRANSIENT_BIT);
+    VkCommandPoolCreateFlagBits allFlags = (VkCommandPoolCreateFlagBits)(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT |
+        VK_COMMAND_POOL_CREATE_TRANSIENT_BIT);
     if(enumerator & (~allFlags))
     {
         return false;
@@ -1519,7 +1519,7 @@
 }
 
 static
-std::string EnumeratorString(VkCmdPoolCreateFlagBits const& enumerator)
+std::string EnumeratorString(VkCommandPoolCreateFlagBits const& enumerator)
 {
     if(!ValidateEnumerator(enumerator))
     {
@@ -1527,13 +1527,13 @@
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)
+    if(enumerator & VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)
     {
-        strings.push_back("VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT");
+        strings.push_back("VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT");
     }
-    if(enumerator & VK_CMD_POOL_CREATE_TRANSIENT_BIT)
+    if(enumerator & VK_COMMAND_POOL_CREATE_TRANSIENT_BIT)
     {
-        strings.push_back("VK_CMD_POOL_CREATE_TRANSIENT_BIT");
+        strings.push_back("VK_COMMAND_POOL_CREATE_TRANSIENT_BIT");
     }
 
     std::string enumeratorString;
@@ -1551,9 +1551,9 @@
 }
 
 static
-bool ValidateEnumerator(VkCmdPoolResetFlagBits const& enumerator)
+bool ValidateEnumerator(VkCommandPoolResetFlagBits const& enumerator)
 {
-    VkCmdPoolResetFlagBits allFlags = (VkCmdPoolResetFlagBits)(VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT);
+    VkCommandPoolResetFlagBits allFlags = (VkCommandPoolResetFlagBits)(VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT);
     if(enumerator & (~allFlags))
     {
         return false;
@@ -1563,7 +1563,7 @@
 }
 
 static
-std::string EnumeratorString(VkCmdPoolResetFlagBits const& enumerator)
+std::string EnumeratorString(VkCommandPoolResetFlagBits const& enumerator)
 {
     if(!ValidateEnumerator(enumerator))
     {
@@ -1571,9 +1571,9 @@
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT)
+    if(enumerator & VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT)
     {
-        strings.push_back("VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT");
+        strings.push_back("VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT");
     }
 
     std::string enumeratorString;
@@ -1591,11 +1591,11 @@
 }
 
 static
-bool ValidateEnumerator(VkCmdBufferUsageFlags const& enumerator)
+bool ValidateEnumerator(VkCommandBufferUsageFlags const& enumerator)
 {
-    VkCmdBufferUsageFlags allFlags = (VkCmdBufferUsageFlags)(VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT |
-        VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT |
-        VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT);
+    VkCommandBufferUsageFlags allFlags = (VkCommandBufferUsageFlags)(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT |
+        VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT |
+        VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT);
     if(enumerator & (~allFlags))
     {
         return false;
@@ -1605,7 +1605,7 @@
 }
 
 static
-std::string EnumeratorString(VkCmdBufferUsageFlags const& enumerator)
+std::string EnumeratorString(VkCommandBufferUsageFlags const& enumerator)
 {
     if(!ValidateEnumerator(enumerator))
     {
@@ -1613,17 +1613,17 @@
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)
+    if(enumerator & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)
     {
-        strings.push_back("VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT");
+        strings.push_back("VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT");
     }
-    if(enumerator & VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
+    if(enumerator & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
     {
-        strings.push_back("VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT");
+        strings.push_back("VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT");
     }
-    if(enumerator & VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)
+    if(enumerator & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)
     {
-        strings.push_back("VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT");
+        strings.push_back("VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT");
     }
 
     std::string enumeratorString;
@@ -1641,9 +1641,9 @@
 }
 
 static
-bool ValidateEnumerator(VkCmdBufferResetFlagBits const& enumerator)
+bool ValidateEnumerator(VkCommandBufferResetFlagBits const& enumerator)
 {
-    VkCmdBufferResetFlagBits allFlags = (VkCmdBufferResetFlagBits)(VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT);
+    VkCommandBufferResetFlagBits allFlags = (VkCommandBufferResetFlagBits)(VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
     if(enumerator & (~allFlags))
     {
         return false;
@@ -1653,7 +1653,7 @@
 }
 
 static
-std::string EnumeratorString(VkCmdBufferResetFlagBits const& enumerator)
+std::string EnumeratorString(VkCommandBufferResetFlagBits const& enumerator)
 {
     if(!ValidateEnumerator(enumerator))
     {
@@ -1661,9 +1661,9 @@
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT)
+    if(enumerator & VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT)
     {
-        strings.push_back("VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT");
+        strings.push_back("VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT");
     }
 
     std::string enumeratorString;
@@ -1777,7 +1777,7 @@
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(
     const VkInstanceCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkInstance* pInstance)
 {
     VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, *pInstance);
@@ -1796,7 +1796,7 @@
 
 VK_LAYER_EXPORT void VKAPI vkDestroyInstance(
     VkInstance instance,
-    const VkAllocCallbacks* pAllocator)
+    const VkAllocationCallbacks* pAllocator)
 {
     // Grab the key before the instance is destroyed.
     dispatch_key key = get_dispatch_key(instance);
@@ -2042,7 +2042,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice physicalDevice,
     const VkDeviceCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkDevice* pDevice)
 {
     /*
@@ -2066,7 +2066,7 @@
 
 VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
     VkDevice device,
-    const VkAllocCallbacks* pAllocator)
+    const VkAllocationCallbacks* pAllocator)
 {
     layer_debug_report_destroy_device(device);
 
@@ -2210,16 +2210,16 @@
     return result;
 }
 
-bool PreAllocMemory(
+bool PreAllocateMemory(
     VkDevice device,
-    const VkMemoryAllocInfo* pAllocInfo)
+    const VkMemoryAllocateInfo* pAllocateInfo)
 {
-    if(pAllocInfo != nullptr)
+    if(pAllocateInfo != nullptr)
     {
-    if(pAllocInfo->sType != VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO)
+    if(pAllocateInfo->sType != VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkAllocMemory parameter, VkStructureType pAllocInfo->sType, is an invalid enumerator");
+        "vkAllocateMemory parameter, VkStructureType pAllocateInfo->sType, is an invalid enumerator");
         return false;
     }
     }
@@ -2227,19 +2227,19 @@
     return true;
 }
 
-bool PostAllocMemory(
+bool PostAllocateMemory(
     VkDevice device,
-    VkDeviceMemory* pMem,
+    VkDeviceMemory* pMemory,
     VkResult result)
 {
 
-    if(pMem != nullptr)
+    if(pMemory != nullptr)
     {
     }
 
     if(result < VK_SUCCESS)
     {
-        std::string reason = "vkAllocMemory parameter, VkResult result, is " + EnumeratorString(result);
+        std::string reason = "vkAllocateMemory parameter, VkResult result, is " + EnumeratorString(result);
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
         return false;
     }
@@ -2247,17 +2247,17 @@
     return true;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateMemory(
     VkDevice device,
-    const VkMemoryAllocInfo* pAllocInfo,
-    const VkAllocCallbacks* pAllocator,
-    VkDeviceMemory* pMem)
+    const VkMemoryAllocateInfo* pAllocateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkDeviceMemory* pMemory)
 {
-    PreAllocMemory(device, pAllocInfo);
+    PreAllocateMemory(device, pAllocateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocMemory(device, pAllocInfo, pAllocator, pMem);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
 
-    PostAllocMemory(device, pMem, result);
+    PostAllocateMemory(device, pMemory, result);
 
     return result;
 }
@@ -2307,14 +2307,14 @@
 
 bool PreFlushMappedMemoryRanges(
     VkDevice device,
-    const VkMappedMemoryRange* pMemRanges)
+    const VkMappedMemoryRange* pMemoryRanges)
 {
-    if(pMemRanges != nullptr)
+    if(pMemoryRanges != nullptr)
     {
-    if(pMemRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE)
+    if(pMemoryRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkFlushMappedMemoryRanges parameter, VkStructureType pMemRanges->sType, is an invalid enumerator");
+        "vkFlushMappedMemoryRanges parameter, VkStructureType pMemoryRanges->sType, is an invalid enumerator");
         return false;
     }
     }
@@ -2324,7 +2324,7 @@
 
 bool PostFlushMappedMemoryRanges(
     VkDevice device,
-    uint32_t memRangeCount,
+    uint32_t memoryRangeCount,
     VkResult result)
 {
 
@@ -2341,28 +2341,28 @@
 
 VK_LAYER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(
     VkDevice device,
-    uint32_t memRangeCount,
-    const VkMappedMemoryRange* pMemRanges)
+    uint32_t memoryRangeCount,
+    const VkMappedMemoryRange* pMemoryRanges)
 {
-    PreFlushMappedMemoryRanges(device, pMemRanges);
+    PreFlushMappedMemoryRanges(device, pMemoryRanges);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
 
-    PostFlushMappedMemoryRanges(device, memRangeCount, result);
+    PostFlushMappedMemoryRanges(device, memoryRangeCount, result);
 
     return result;
 }
 
 bool PreInvalidateMappedMemoryRanges(
     VkDevice device,
-    const VkMappedMemoryRange* pMemRanges)
+    const VkMappedMemoryRange* pMemoryRanges)
 {
-    if(pMemRanges != nullptr)
+    if(pMemoryRanges != nullptr)
     {
-    if(pMemRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE)
+    if(pMemoryRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkInvalidateMappedMemoryRanges parameter, VkStructureType pMemRanges->sType, is an invalid enumerator");
+        "vkInvalidateMappedMemoryRanges parameter, VkStructureType pMemoryRanges->sType, is an invalid enumerator");
         return false;
     }
     }
@@ -2372,7 +2372,7 @@
 
 bool PostInvalidateMappedMemoryRanges(
     VkDevice device,
-    uint32_t memRangeCount,
+    uint32_t memoryRangeCount,
     VkResult result)
 {
 
@@ -2389,14 +2389,14 @@
 
 VK_LAYER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(
     VkDevice device,
-    uint32_t memRangeCount,
-    const VkMappedMemoryRange* pMemRanges)
+    uint32_t memoryRangeCount,
+    const VkMappedMemoryRange* pMemoryRanges)
 {
-    PreInvalidateMappedMemoryRanges(device, pMemRanges);
+    PreInvalidateMappedMemoryRanges(device, pMemoryRanges);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
 
-    PostInvalidateMappedMemoryRanges(device, memRangeCount, result);
+    PostInvalidateMappedMemoryRanges(device, memoryRangeCount, result);
 
     return result;
 }
@@ -2429,7 +2429,7 @@
     VkDevice device,
     VkBuffer buffer,
     VkDeviceMemory mem,
-    VkDeviceSize memOffset,
+    VkDeviceSize memoryOffset,
     VkResult result)
 {
 
@@ -2450,11 +2450,11 @@
     VkDevice device,
     VkBuffer buffer,
     VkDeviceMemory mem,
-    VkDeviceSize memOffset)
+    VkDeviceSize memoryOffset)
 {
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->BindBufferMemory(device, buffer, mem, memOffset);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->BindBufferMemory(device, buffer, mem, memoryOffset);
 
-    PostBindBufferMemory(device, buffer, mem, memOffset, result);
+    PostBindBufferMemory(device, buffer, mem, memoryOffset, result);
 
     return result;
 }
@@ -2463,7 +2463,7 @@
     VkDevice device,
     VkImage image,
     VkDeviceMemory mem,
-    VkDeviceSize memOffset,
+    VkDeviceSize memoryOffset,
     VkResult result)
 {
 
@@ -2484,11 +2484,11 @@
     VkDevice device,
     VkImage image,
     VkDeviceMemory mem,
-    VkDeviceSize memOffset)
+    VkDeviceSize memoryOffset)
 {
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->BindImageMemory(device, image, mem, memOffset);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->BindImageMemory(device, image, mem, memoryOffset);
 
-    PostBindImageMemory(device, image, mem, memOffset, result);
+    PostBindImageMemory(device, image, mem, memoryOffset, result);
 
     return result;
 }
@@ -2735,7 +2735,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
     VkDevice device,
     const VkFenceCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkFence* pFence)
 {
     PreCreateFence(device, pCreateInfo);
@@ -2905,7 +2905,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(
     VkDevice device,
     const VkSemaphoreCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkSemaphore* pSemaphore)
 {
     PreCreateSemaphore(device, pCreateInfo);
@@ -2957,7 +2957,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(
     VkDevice device,
     const VkEventCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkEvent* pEvent)
 {
     PreCreateEvent(device, pCreateInfo);
@@ -3100,7 +3100,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(
     VkDevice device,
     const VkQueryPoolCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkQueryPool* pQueryPool)
 {
     PreCreateQueryPool(device, pCreateInfo);
@@ -3209,7 +3209,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
     VkDevice device,
     const VkBufferCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkBuffer* pBuffer)
 {
     PreCreateBuffer(device, pCreateInfo);
@@ -3268,7 +3268,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
     VkDevice device,
     const VkBufferViewCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkBufferView* pView)
 {
     PreCreateBufferView(device, pCreateInfo);
@@ -3351,7 +3351,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
     VkDevice device,
     const VkImageCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkImage* pImage)
 {
     PreCreateImage(device, pCreateInfo);
@@ -3490,7 +3490,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
     VkDevice device,
     const VkImageViewCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkImageView* pView)
 {
     PreCreateImageView(device, pCreateInfo);
@@ -3543,7 +3543,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateShaderModule(
     VkDevice device,
     const VkShaderModuleCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkShaderModule* pShaderModule)
 {
     PreCreateShaderModule(device, pCreateInfo);
@@ -3595,7 +3595,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
     VkDevice device,
     const VkShaderCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkShader* pShader)
 {
     PreCreateShader(device, pCreateInfo);
@@ -3650,7 +3650,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineCache(
     VkDevice device,
     const VkPipelineCacheCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkPipelineCache* pPipelineCache)
 {
     PreCreatePipelineCache(device, pCreateInfo);
@@ -3715,7 +3715,7 @@
 
 bool PostMergePipelineCaches(
     VkDevice device,
-    VkPipelineCache destCache,
+    VkPipelineCache dstCache,
     uint32_t srcCacheCount,
     VkResult result)
 {
@@ -3734,15 +3734,15 @@
 
 VK_LAYER_EXPORT VkResult VKAPI vkMergePipelineCaches(
     VkDevice device,
-    VkPipelineCache destCache,
+    VkPipelineCache dstCache,
     uint32_t srcCacheCount,
     const VkPipelineCache* pSrcCaches)
 {
     PreMergePipelineCaches(device, pSrcCaches);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
 
-    PostMergePipelineCaches(device, destCache, srcCacheCount, result);
+    PostMergePipelineCaches(device, dstCache, srcCacheCount, result);
 
     return result;
 }
@@ -3840,32 +3840,32 @@
         return false;
     }
     }
-    if(pCreateInfos->pRasterState != nullptr)
+    if(pCreateInfos->pRasterizationState != nullptr)
     {
-    if(pCreateInfos->pRasterState->sType != VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO)
+    if(pCreateInfos->pRasterizationState->sType != VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pRasterState->sType, is an invalid enumerator");
+        "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pRasterizationState->sType, is an invalid enumerator");
         return false;
     }
-    if(pCreateInfos->pRasterState->fillMode < VK_FILL_MODE_BEGIN_RANGE ||
-        pCreateInfos->pRasterState->fillMode > VK_FILL_MODE_END_RANGE)
+    if(pCreateInfos->pRasterizationState->fillMode < VK_FILL_MODE_BEGIN_RANGE ||
+        pCreateInfos->pRasterizationState->fillMode > VK_FILL_MODE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkFillMode pCreateInfos->pRasterState->fillMode, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkFillMode pCreateInfos->pRasterizationState->fillMode, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pRasterState->cullMode & ~VK_CULL_MODE_FRONT_AND_BACK)
+    if(pCreateInfos->pRasterizationState->cullMode & ~VK_CULL_MODE_FRONT_AND_BACK)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkCullMode pCreateInfos->pRasterState->cullMode, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkCullMode pCreateInfos->pRasterizationState->cullMode, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pRasterState->frontFace < VK_FRONT_FACE_BEGIN_RANGE ||
-        pCreateInfos->pRasterState->frontFace > VK_FRONT_FACE_END_RANGE)
+    if(pCreateInfos->pRasterizationState->frontFace < VK_FRONT_FACE_BEGIN_RANGE ||
+        pCreateInfos->pRasterizationState->frontFace > VK_FRONT_FACE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkFrontFace pCreateInfos->pRasterState->frontFace, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkFrontFace pCreateInfos->pRasterizationState->frontFace, is an unrecognized enumerator");
         return false;
     }
     }
@@ -3975,11 +3975,11 @@
         "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->srcBlendColor, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pColorBlendState->pAttachments->destBlendColor < VK_BLEND_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->destBlendColor > VK_BLEND_END_RANGE)
+    if(pCreateInfos->pColorBlendState->pAttachments->dstBlendColor < VK_BLEND_BEGIN_RANGE ||
+        pCreateInfos->pColorBlendState->pAttachments->dstBlendColor > 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->destBlendColor, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->dstBlendColor, is an unrecognized enumerator");
         return false;
     }
     if(pCreateInfos->pColorBlendState->pAttachments->blendOpColor < VK_BLEND_OP_BEGIN_RANGE ||
@@ -3996,11 +3996,11 @@
         "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->srcBlendAlpha, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfos->pColorBlendState->pAttachments->destBlendAlpha < VK_BLEND_BEGIN_RANGE ||
-        pCreateInfos->pColorBlendState->pAttachments->destBlendAlpha > VK_BLEND_END_RANGE)
+    if(pCreateInfos->pColorBlendState->pAttachments->dstBlendAlpha < VK_BLEND_BEGIN_RANGE ||
+        pCreateInfos->pColorBlendState->pAttachments->dstBlendAlpha > 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->destBlendAlpha, is an unrecognized enumerator");
+        "vkCreateGraphicsPipelines parameter, VkBlend pCreateInfos->pColorBlendState->pAttachments->dstBlendAlpha, is an unrecognized enumerator");
         return false;
     }
     if(pCreateInfos->pColorBlendState->pAttachments->blendOpAlpha < VK_BLEND_OP_BEGIN_RANGE ||
@@ -4051,7 +4051,7 @@
     VkPipelineCache pipelineCache,
     uint32_t count,
     const VkGraphicsPipelineCreateInfo* pCreateInfos,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkPipeline* pPipelines)
 {
     PreCreateGraphicsPipelines(device, pCreateInfos);
@@ -4124,7 +4124,7 @@
     VkPipelineCache pipelineCache,
     uint32_t count,
     const VkComputePipelineCreateInfo* pCreateInfos,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkPipeline* pPipelines)
 {
     PreCreateComputePipelines(device, pCreateInfos);
@@ -4182,7 +4182,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
     VkDevice device,
     const VkPipelineLayoutCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkPipelineLayout* pPipelineLayout)
 {
     PreCreatePipelineLayout(device, pCreateInfo);
@@ -4290,7 +4290,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(
     VkDevice device,
     const VkSamplerCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkSampler* pSampler)
 {
     PreCreateSampler(device, pCreateInfo);
@@ -4355,7 +4355,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
     VkDevice device,
     const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkDescriptorSetLayout* pSetLayout)
 {
     PreCreateDescriptorSetLayout(device, pCreateInfo);
@@ -4420,7 +4420,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(
     VkDevice device,
     const VkDescriptorPoolCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkDescriptorPool* pDescriptorPool)
 {
     PreCreateDescriptorPool(device, pCreateInfo);
@@ -4461,7 +4461,7 @@
     return result;
 }
 
-bool PreAllocDescriptorSets(
+bool PreAllocateDescriptorSets(
     VkDevice device,
     const VkDescriptorSetLayout* pSetLayouts)
 {
@@ -4472,7 +4472,7 @@
     return true;
 }
 
-bool PostAllocDescriptorSets(
+bool PostAllocateDescriptorSets(
     VkDevice device,
     VkDescriptorPool descriptorPool,
     uint32_t count,
@@ -4487,7 +4487,7 @@
 
     if(result < VK_SUCCESS)
     {
-        std::string reason = "vkAllocDescriptorSets parameter, VkResult result, is " + EnumeratorString(result);
+        std::string reason = "vkAllocateDescriptorSets parameter, VkResult result, is " + EnumeratorString(result);
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
         return false;
     }
@@ -4495,16 +4495,16 @@
     return true;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateDescriptorSets(
     VkDevice device,
-    const VkDescriptorSetAllocInfo* pAllocInfo,
+    const VkDescriptorSetAllocateInfo* pAllocateInfo,
     VkDescriptorSet* pDescriptorSets)
 {
-    PreAllocDescriptorSets(device, pAllocInfo->pSetLayouts);
+    PreAllocateDescriptorSets(device, pAllocateInfo->pSetLayouts);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
 
-    PostAllocDescriptorSets(device, pAllocInfo->descriptorPool, pAllocInfo->setLayoutCount, pDescriptorSets, result);
+    PostAllocateDescriptorSets(device, pAllocateInfo->descriptorPool, pAllocateInfo->setLayoutCount, pDescriptorSets, result);
 
     return result;
 }
@@ -4656,7 +4656,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(
     VkDevice device,
     const VkFramebufferCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkFramebuffer* pFramebuffer)
 {
     PreCreateFramebuffer(device, pCreateInfo);
@@ -4821,7 +4821,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
     VkDevice device,
     const VkRenderPassCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkRenderPass* pRenderPass)
 {
     PreCreateRenderPass(device, pCreateInfo);
@@ -4859,11 +4859,11 @@
 
 bool PreCreateCommandPool(
     VkDevice device,
-    const VkCmdPoolCreateInfo* pCreateInfo)
+    const VkCommandPoolCreateInfo* pCreateInfo)
 {
     if(pCreateInfo != nullptr)
     {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO)
+    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCreateCommandPool parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
@@ -4876,11 +4876,11 @@
 
 bool PostCreateCommandPool(
     VkDevice device,
-    VkCmdPool* pCmdPool,
+    VkCommandPool* pCommandPool,
     VkResult result)
 {
 
-    if(pCmdPool != nullptr)
+    if(pCommandPool != nullptr)
     {
     }
 
@@ -4896,23 +4896,23 @@
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(
     VkDevice device,
-    const VkCmdPoolCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
-    VkCmdPool* pCmdPool)
+    const VkCommandPoolCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkCommandPool* pCommandPool)
 {
     PreCreateCommandPool(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
 
-    PostCreateCommandPool(device, pCmdPool, result);
+    PostCreateCommandPool(device, pCommandPool, result);
 
     return result;
 }
 
 bool PostResetCommandPool(
     VkDevice device,
-    VkCmdPool cmdPool,
-    VkCmdPoolResetFlags flags,
+    VkCommandPool commandPool,
+    VkCommandPoolResetFlags flags,
     VkResult result)
 {
 
@@ -4930,33 +4930,33 @@
 
 VK_LAYER_EXPORT VkResult VKAPI vkResetCommandPool(
     VkDevice device,
-    VkCmdPool cmdPool,
-    VkCmdPoolResetFlags flags)
+    VkCommandPool commandPool,
+    VkCommandPoolResetFlags flags)
 {
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetCommandPool(device, cmdPool, flags);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetCommandPool(device, commandPool, flags);
 
-    PostResetCommandPool(device, cmdPool, flags, result);
+    PostResetCommandPool(device, commandPool, flags, result);
 
     return result;
 }
 
 bool PreCreateCommandBuffer(
     VkDevice device,
-    const VkCmdBufferAllocInfo* pCreateInfo)
+    const VkCommandBufferAllocateInfo* pCreateInfo)
 {
     if(pCreateInfo != nullptr)
     {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO)
+    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkAllocCommandBuffers parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
+        "vkAllocateCommandBuffers parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
         return false;
     }
-    if(pCreateInfo->level < VK_CMD_BUFFER_LEVEL_BEGIN_RANGE ||
-        pCreateInfo->level > VK_CMD_BUFFER_LEVEL_END_RANGE)
+    if(pCreateInfo->level < VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE ||
+        pCreateInfo->level > VK_COMMAND_BUFFER_LEVEL_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkAllocCommandBuffers parameter, VkCmdBufferLevel pCreateInfo->level, is an unrecognized enumerator");
+        "vkAllocateCommandBuffers parameter, VkCommandBufferLevel pCreateInfo->level, is an unrecognized enumerator");
         return false;
     }
     }
@@ -4966,17 +4966,17 @@
 
 bool PostCreateCommandBuffer(
     VkDevice device,
-    VkCmdBuffer* pCmdBuffer,
+    VkCommandBuffer* pCommandBuffer,
     VkResult result)
 {
 
-    if(pCmdBuffer != nullptr)
+    if(pCommandBuffer != nullptr)
     {
     }
 
     if(result < VK_SUCCESS)
     {
-        std::string reason = "vkAllocCommandBuffers parameter, VkResult result, is " + EnumeratorString(result);
+        std::string reason = "vkAllocateCommandBuffers parameter, VkResult result, is " + EnumeratorString(result);
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
         return false;
     }
@@ -4984,29 +4984,29 @@
     return true;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocateCommandBuffers(
     VkDevice device,
-    const VkCmdBufferAllocInfo* pCreateInfo,
-    VkCmdBuffer* pCmdBuffer)
+    const VkCommandBufferAllocateInfo* pCreateInfo,
+    VkCommandBuffer* pCommandBuffer)
 {
     PreCreateCommandBuffer(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
 
-    PostCreateCommandBuffer(device, pCmdBuffer, result);
+    PostCreateCommandBuffer(device, pCommandBuffer, result);
 
     return result;
 }
 
 bool PreBeginCommandBuffer(
-    VkCmdBuffer cmdBuffer,
-    const VkCmdBufferBeginInfo* pBeginInfo)
+    VkCommandBuffer commandBuffer,
+    const VkCommandBufferBeginInfo* pBeginInfo)
 {
     if(pBeginInfo != nullptr)
     {
-    if(pBeginInfo->sType != VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO)
+    if(pBeginInfo->sType != VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkBeginCommandBuffer parameter, VkStructureType pBeginInfo->sType, is an invalid enumerator");
         return false;
     }
@@ -5016,14 +5016,14 @@
 }
 
 bool PostBeginCommandBuffer(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkResult result)
 {
 
     if(result < VK_SUCCESS)
     {
         std::string reason = "vkBeginCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
         return false;
     }
 
@@ -5031,27 +5031,27 @@
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(
-    VkCmdBuffer cmdBuffer,
-    const VkCmdBufferBeginInfo* pBeginInfo)
+    VkCommandBuffer commandBuffer,
+    const VkCommandBufferBeginInfo* pBeginInfo)
 {
-    PreBeginCommandBuffer(cmdBuffer, pBeginInfo);
+    PreBeginCommandBuffer(commandBuffer, pBeginInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+    VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)->BeginCommandBuffer(commandBuffer, pBeginInfo);
 
-    PostBeginCommandBuffer(cmdBuffer, result);
+    PostBeginCommandBuffer(commandBuffer, result);
 
     return result;
 }
 
 bool PostEndCommandBuffer(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkResult result)
 {
 
     if(result < VK_SUCCESS)
     {
         std::string reason = "vkEndCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
         return false;
     }
 
@@ -5059,18 +5059,18 @@
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(
-    VkCmdBuffer cmdBuffer)
+    VkCommandBuffer commandBuffer)
 {
-    VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->EndCommandBuffer(cmdBuffer);
+    VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)->EndCommandBuffer(commandBuffer);
 
-    PostEndCommandBuffer(cmdBuffer, result);
+    PostEndCommandBuffer(commandBuffer, result);
 
     return result;
 }
 
 bool PostResetCommandBuffer(
-    VkCmdBuffer cmdBuffer,
-    VkCmdBufferResetFlags flags,
+    VkCommandBuffer commandBuffer,
+    VkCommandBufferResetFlags flags,
     VkResult result)
 {
 
@@ -5078,7 +5078,7 @@
     if(result < VK_SUCCESS)
     {
         std::string reason = "vkResetCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
         return false;
     }
 
@@ -5086,18 +5086,18 @@
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(
-    VkCmdBuffer cmdBuffer,
-    VkCmdBufferResetFlags flags)
+    VkCommandBuffer commandBuffer,
+    VkCommandBufferResetFlags flags)
 {
-    VkResult result = get_dispatch_table(pc_device_table_map, cmdBuffer)->ResetCommandBuffer(cmdBuffer, flags);
+    VkResult result = get_dispatch_table(pc_device_table_map, commandBuffer)->ResetCommandBuffer(commandBuffer, flags);
 
-    PostResetCommandBuffer(cmdBuffer, flags, result);
+    PostResetCommandBuffer(commandBuffer, flags, result);
 
     return result;
 }
 
 bool PostCmdBindPipeline(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkPipelineBindPoint pipelineBindPoint,
     VkPipeline pipeline)
 {
@@ -5105,7 +5105,7 @@
     if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
         pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdBindPipeline parameter, VkPipelineBindPoint pipelineBindPoint, is an unrecognized enumerator");
         return false;
     }
@@ -5115,62 +5115,62 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkPipelineBindPoint pipelineBindPoint,
     VkPipeline pipeline)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 
-    PostCmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+    PostCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports)
+VK_LAYER_EXPORT void VKAPI vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetViewport(cmdBuffer, viewportCount, pViewports);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetViewport(commandBuffer, viewportCount, pViewports);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
+VK_LAYER_EXPORT void VKAPI vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetScissor(cmdBuffer, scissorCount, pScissors);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetScissor(commandBuffer, scissorCount, pScissors);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth)
+VK_LAYER_EXPORT void VKAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetLineWidth(cmdBuffer, lineWidth);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetDepthBias(cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConstants[4])
+VK_LAYER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetBlendConstants(cmdBuffer, blendConstants);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds)
+VK_LAYER_EXPORT void VKAPI vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask)
+VK_LAYER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask)
+VK_LAYER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference)
+VK_LAYER_EXPORT void VKAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
 }
 
 bool PreCmdBindDescriptorSets(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkDescriptorSet* pDescriptorSets,
     const uint32_t* pDynamicOffsets)
 {
@@ -5186,7 +5186,7 @@
 }
 
 bool PostCmdBindDescriptorSets(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkPipelineBindPoint pipelineBindPoint,
     VkPipelineLayout layout,
     uint32_t firstSet,
@@ -5197,7 +5197,7 @@
     if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE ||
         pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdBindDescriptorSets parameter, VkPipelineBindPoint pipelineBindPoint, is an unrecognized enumerator");
         return false;
     }
@@ -5210,7 +5210,7 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkPipelineBindPoint pipelineBindPoint,
     VkPipelineLayout layout,
     uint32_t firstSet,
@@ -5219,15 +5219,15 @@
     uint32_t dynamicOffsetCount,
     const uint32_t* pDynamicOffsets)
 {
-    PreCmdBindDescriptorSets(cmdBuffer, pDescriptorSets, pDynamicOffsets);
+    PreCmdBindDescriptorSets(commandBuffer, pDescriptorSets, pDynamicOffsets);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 
-    PostCmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, dynamicOffsetCount);
+    PostCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, dynamicOffsetCount);
 }
 
 bool PostCmdBindIndexBuffer(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer buffer,
     VkDeviceSize offset,
     VkIndexType indexType)
@@ -5238,7 +5238,7 @@
     if(indexType < VK_INDEX_TYPE_BEGIN_RANGE ||
         indexType > VK_INDEX_TYPE_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdBindIndexBuffer parameter, VkIndexType indexType, is an unrecognized enumerator");
         return false;
     }
@@ -5247,18 +5247,18 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer buffer,
     VkDeviceSize offset,
     VkIndexType indexType)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 
-    PostCmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+    PostCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 }
 
 bool PreCmdBindVertexBuffers(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkBuffer* pBuffers,
     const VkDeviceSize* pOffsets)
 {
@@ -5274,7 +5274,7 @@
 }
 
 bool PostCmdBindVertexBuffers(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     uint32_t startBinding,
     uint32_t bindingCount)
 {
@@ -5285,21 +5285,21 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     uint32_t startBinding,
     uint32_t bindingCount,
     const VkBuffer* pBuffers,
     const VkDeviceSize* pOffsets)
 {
-    PreCmdBindVertexBuffers(cmdBuffer, pBuffers, pOffsets);
+    PreCmdBindVertexBuffers(commandBuffer, pBuffers, pOffsets);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets);
 
-    PostCmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount);
+    PostCmdBindVertexBuffers(commandBuffer, startBinding, bindingCount);
 }
 
 bool PostCmdDraw(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     uint32_t firstVertex,
     uint32_t vertexCount,
     uint32_t firstInstance,
@@ -5314,19 +5314,19 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDraw(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     uint32_t vertexCount,
     uint32_t instanceCount,
     uint32_t firstVertex,
     uint32_t firstInstance)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDraw(cmdBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
 
-    PostCmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
+    PostCmdDraw(commandBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
 }
 
 bool PostCmdDrawIndexed(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     uint32_t firstIndex,
     uint32_t indexCount,
     int32_t vertexOffset,
@@ -5343,20 +5343,20 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     uint32_t indexCount,
     uint32_t instanceCount,
     uint32_t firstIndex,
     int32_t vertexOffset,
     uint32_t firstInstance)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndexed(cmdBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 
-    PostCmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
+    PostCmdDrawIndexed(commandBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
 }
 
 bool PostCmdDrawIndirect(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer buffer,
     VkDeviceSize offset,
     uint32_t count,
@@ -5371,19 +5371,19 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer buffer,
     VkDeviceSize offset,
     uint32_t count,
     uint32_t stride)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
 
-    PostCmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+    PostCmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
 }
 
 bool PostCmdDrawIndexedIndirect(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer buffer,
     VkDeviceSize offset,
     uint32_t count,
@@ -5398,19 +5398,19 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer buffer,
     VkDeviceSize offset,
     uint32_t count,
     uint32_t stride)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
 
-    PostCmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+    PostCmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
 }
 
 bool PostCmdDispatch(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     uint32_t x,
     uint32_t y,
     uint32_t z)
@@ -5423,18 +5423,18 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDispatch(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     uint32_t x,
     uint32_t y,
     uint32_t z)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDispatch(cmdBuffer, x, y, z);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDispatch(commandBuffer, x, y, z);
 
-    PostCmdDispatch(cmdBuffer, x, y, z);
+    PostCmdDispatch(commandBuffer, x, y, z);
 }
 
 bool PostCmdDispatchIndirect(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer buffer,
     VkDeviceSize offset)
 {
@@ -5445,17 +5445,17 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer buffer,
     VkDeviceSize offset)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset);
 
-    PostCmdDispatchIndirect(cmdBuffer, buffer, offset);
+    PostCmdDispatchIndirect(commandBuffer, buffer, offset);
 }
 
 bool PreCmdCopyBuffer(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkBufferCopy* pRegions)
 {
     if(pRegions != nullptr)
@@ -5466,9 +5466,9 @@
 }
 
 bool PostCmdCopyBuffer(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer srcBuffer,
-    VkBuffer destBuffer,
+    VkBuffer dstBuffer,
     uint32_t regionCount)
 {
 
@@ -5479,21 +5479,21 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer srcBuffer,
-    VkBuffer destBuffer,
+    VkBuffer dstBuffer,
     uint32_t regionCount,
     const VkBufferCopy* pRegions)
 {
-    PreCmdCopyBuffer(cmdBuffer, pRegions);
+    PreCmdCopyBuffer(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
 
-    PostCmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount);
+    PostCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount);
 }
 
 bool PreCmdCopyImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkImageCopy* pRegions)
 {
     if(pRegions != nullptr)
@@ -5501,15 +5501,15 @@
     if ((pRegions->srcSubresource.aspect &
        (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdCopyImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is an unrecognized enumerator");
         return false;
     }
-    if ((pRegions->destSubresource.aspect &
+    if ((pRegions->dstSubresource.aspect &
        (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCmdCopyImage parameter, VkImageAspect pRegions->destSubresource.aspect, is an unrecognized enumerator");
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        "vkCmdCopyImage parameter, VkImageAspect pRegions->dstSubresource.aspect, is an unrecognized enumerator");
         return false;
     }
     }
@@ -5518,11 +5518,11 @@
 }
 
 bool PostCmdCopyImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage srcImage,
     VkImageLayout srcImageLayout,
-    VkImage destImage,
-    VkImageLayout destImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
     uint32_t regionCount)
 {
 
@@ -5530,17 +5530,17 @@
     if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
         srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdCopyImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
         return false;
     }
 
 
-    if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
-        destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
+    if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
+        dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCmdCopyImage parameter, VkImageLayout destImageLayout, is an unrecognized enumerator");
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        "vkCmdCopyImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
         return false;
     }
 
@@ -5549,23 +5549,23 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage srcImage,
     VkImageLayout srcImageLayout,
-    VkImage destImage,
-    VkImageLayout destImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
     uint32_t regionCount,
     const VkImageCopy* pRegions)
 {
-    PreCmdCopyImage(cmdBuffer, pRegions);
+    PreCmdCopyImage(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 
-    PostCmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount);
+    PostCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount);
 }
 
 bool PreCmdBlitImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkImageBlit* pRegions)
 {
     if(pRegions != nullptr)
@@ -5573,15 +5573,15 @@
     if ((pRegions->srcSubresource.aspect &
        (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdCopyImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is an unrecognized enumerator");
         return false;
     }
-    if ((pRegions->destSubresource.aspect &
+    if ((pRegions->dstSubresource.aspect &
        (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCmdCopyImage parameter, VkImageAspect pRegions->destSubresource.aspect, is an unrecognized enumerator");
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        "vkCmdCopyImage parameter, VkImageAspect pRegions->dstSubresource.aspect, is an unrecognized enumerator");
         return false;
     }
     }
@@ -5590,11 +5590,11 @@
 }
 
 bool PostCmdBlitImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage srcImage,
     VkImageLayout srcImageLayout,
-    VkImage destImage,
-    VkImageLayout destImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
     uint32_t regionCount,
     VkFilter filter)
 {
@@ -5603,17 +5603,17 @@
     if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
         srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdBlitImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
         return false;
     }
 
 
-    if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
-        destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
+    if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
+        dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCmdBlitImage parameter, VkImageLayout destImageLayout, is an unrecognized enumerator");
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        "vkCmdBlitImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
         return false;
     }
 
@@ -5621,7 +5621,7 @@
     if(filter < VK_FILTER_BEGIN_RANGE ||
         filter > VK_FILTER_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdBlitImage parameter, VkFilter filter, is an unrecognized enumerator");
         return false;
     }
@@ -5630,24 +5630,24 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage srcImage,
     VkImageLayout srcImageLayout,
-    VkImage destImage,
-    VkImageLayout destImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
     uint32_t regionCount,
     const VkImageBlit* pRegions,
     VkFilter filter)
 {
-    PreCmdBlitImage(cmdBuffer, pRegions);
+    PreCmdBlitImage(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
 
-    PostCmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, filter);
+    PostCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, filter);
 }
 
 bool PreCmdCopyBufferToImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkBufferImageCopy* pRegions)
 {
     if(pRegions != nullptr)
@@ -5655,7 +5655,7 @@
     if ((pRegions->imageSubresource.aspect &
        (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdCopyBufferToImage parameter, VkImageAspect pRegions->imageSubresource.aspect, is an unrecognized enumerator");
         return false;
     }
@@ -5665,20 +5665,20 @@
 }
 
 bool PostCmdCopyBufferToImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer srcBuffer,
-    VkImage destImage,
-    VkImageLayout destImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
     uint32_t regionCount)
 {
 
 
 
-    if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
-        destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
+    if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
+        dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCmdCopyBufferToImage parameter, VkImageLayout destImageLayout, is an unrecognized enumerator");
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        "vkCmdCopyBufferToImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
         return false;
     }
 
@@ -5687,22 +5687,22 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkBuffer srcBuffer,
-    VkImage destImage,
-    VkImageLayout destImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
     uint32_t regionCount,
     const VkBufferImageCopy* pRegions)
 {
-    PreCmdCopyBufferToImage(cmdBuffer, pRegions);
+    PreCmdCopyBufferToImage(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
 
-    PostCmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount);
+    PostCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount);
 }
 
 bool PreCmdCopyImageToBuffer(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkBufferImageCopy* pRegions)
 {
     if(pRegions != nullptr)
@@ -5710,7 +5710,7 @@
     if ((pRegions->imageSubresource.aspect &
        (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdCopyImageToBuffer parameter, VkImageAspect pRegions->imageSubresource.aspect, is an unrecognized enumerator");
         return false;
     }
@@ -5720,10 +5720,10 @@
 }
 
 bool PostCmdCopyImageToBuffer(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage srcImage,
     VkImageLayout srcImageLayout,
-    VkBuffer destBuffer,
+    VkBuffer dstBuffer,
     uint32_t regionCount)
 {
 
@@ -5731,7 +5731,7 @@
     if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
         srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdCopyImageToBuffer parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
         return false;
     }
@@ -5742,22 +5742,22 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage srcImage,
     VkImageLayout srcImageLayout,
-    VkBuffer destBuffer,
+    VkBuffer dstBuffer,
     uint32_t regionCount,
     const VkBufferImageCopy* pRegions)
 {
-    PreCmdCopyImageToBuffer(cmdBuffer, pRegions);
+    PreCmdCopyImageToBuffer(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
 
-    PostCmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount);
+    PostCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount);
 }
 
 bool PreCmdUpdateBuffer(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const uint32_t* pData)
 {
     if(pData != nullptr)
@@ -5768,9 +5768,9 @@
 }
 
 bool PostCmdUpdateBuffer(
-    VkCmdBuffer cmdBuffer,
-    VkBuffer destBuffer,
-    VkDeviceSize destOffset,
+    VkCommandBuffer commandBuffer,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
     VkDeviceSize dataSize)
 {
 
@@ -5781,23 +5781,23 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(
-    VkCmdBuffer cmdBuffer,
-    VkBuffer destBuffer,
-    VkDeviceSize destOffset,
+    VkCommandBuffer commandBuffer,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
     VkDeviceSize dataSize,
     const uint32_t* pData)
 {
-    PreCmdUpdateBuffer(cmdBuffer, pData);
+    PreCmdUpdateBuffer(commandBuffer, pData);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 
-    PostCmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize);
+    PostCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize);
 }
 
 bool PostCmdFillBuffer(
-    VkCmdBuffer cmdBuffer,
-    VkBuffer destBuffer,
-    VkDeviceSize destOffset,
+    VkCommandBuffer commandBuffer,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
     VkDeviceSize size,
     uint32_t data)
 {
@@ -5810,19 +5810,19 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
-    VkCmdBuffer cmdBuffer,
-    VkBuffer destBuffer,
-    VkDeviceSize destOffset,
+    VkCommandBuffer commandBuffer,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
     VkDeviceSize size,
     uint32_t data)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 
-    PostCmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+    PostCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 }
 
 bool PreCmdClearColorImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkClearColorValue* pColor,
     const VkImageSubresourceRange* pRanges)
 {
@@ -5839,7 +5839,7 @@
 }
 
 bool PostCmdClearColorImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage image,
     VkImageLayout imageLayout,
     uint32_t rangeCount)
@@ -5849,7 +5849,7 @@
     if(imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
         imageLayout > VK_IMAGE_LAYOUT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdClearColorImage parameter, VkImageLayout imageLayout, is an unrecognized enumerator");
         return false;
     }
@@ -5859,22 +5859,22 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage image,
     VkImageLayout imageLayout,
     const VkClearColorValue* pColor,
     uint32_t rangeCount,
     const VkImageSubresourceRange* pRanges)
 {
-    PreCmdClearColorImage(cmdBuffer, pColor, pRanges);
+    PreCmdClearColorImage(commandBuffer, pColor, pRanges);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 
-    PostCmdClearColorImage(cmdBuffer, image, imageLayout, rangeCount);
+    PostCmdClearColorImage(commandBuffer, image, imageLayout, rangeCount);
 }
 
 bool PreCmdClearDepthStencilImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkImageSubresourceRange* pRanges)
 {
     if(pRanges != nullptr)
@@ -5890,7 +5890,7 @@
 }
 
 bool PostCmdClearDepthStencilImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage image,
     VkImageLayout imageLayout,
     const VkClearDepthStencilValue* pDepthStencil,
@@ -5901,7 +5901,7 @@
     if(imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
         imageLayout > VK_IMAGE_LAYOUT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdClearDepthStencilImage parameter, VkImageLayout imageLayout, is an unrecognized enumerator");
         return false;
     }
@@ -5913,22 +5913,22 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencilImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage image,
     VkImageLayout imageLayout,
     const VkClearDepthStencilValue* pDepthStencil,
     uint32_t rangeCount,
     const VkImageSubresourceRange* pRanges)
 {
-    PreCmdClearDepthStencilImage(cmdBuffer, pRanges);
+    PreCmdClearDepthStencilImage(commandBuffer, pRanges);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 
-    PostCmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount);
+    PostCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount);
 }
 
 bool PreCmdClearAttachments(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkClearColorValue* pColor,
     const VkClearRect* pRects)
 {
@@ -5944,21 +5944,21 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearAttachments(
-    VkCmdBuffer                                 cmdBuffer,
+    VkCommandBuffer                                 commandBuffer,
     uint32_t                                    attachmentCount,
     const VkClearAttachment*                    pAttachments,
     uint32_t                                    rectCount,
     const VkClearRect*                          pRects)
 {
     for (uint32_t i = 0; i < attachmentCount; i++) {
-        PreCmdClearAttachments(cmdBuffer, &pAttachments[i].clearValue.color, pRects);
+        PreCmdClearAttachments(commandBuffer, &pAttachments[i].clearValue.color, pRects);
     }
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdClearAttachments(cmdBuffer, attachmentCount, pAttachments, rectCount, pRects);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
 }
 
 bool PreCmdResolveImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkImageResolve* pRegions)
 {
     if(pRegions != nullptr)
@@ -5966,15 +5966,15 @@
     if ((pRegions->srcSubresource.aspect &
        (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdResolveImage parameter, VkImageAspect pRegions->srcSubresource.aspect, is an unrecognized enumerator");
         return false;
     }
-    if ((pRegions->destSubresource.aspect &
+    if ((pRegions->dstSubresource.aspect &
        (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCmdResolveImage parameter, VkImageAspect pRegions->destSubresource.aspect, is an unrecognized enumerator");
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        "vkCmdResolveImage parameter, VkImageAspect pRegions->dstSubresource.aspect, is an unrecognized enumerator");
         return false;
     }
     }
@@ -5983,11 +5983,11 @@
 }
 
 bool PostCmdResolveImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage srcImage,
     VkImageLayout srcImageLayout,
-    VkImage destImage,
-    VkImageLayout destImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
     uint32_t regionCount)
 {
 
@@ -5995,17 +5995,17 @@
     if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
         srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdResolveImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator");
         return false;
     }
 
 
-    if(destImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
-        destImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
+    if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
+        dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCmdResolveImage parameter, VkImageLayout destImageLayout, is an unrecognized enumerator");
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        "vkCmdResolveImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator");
         return false;
     }
 
@@ -6014,23 +6014,23 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkImage srcImage,
     VkImageLayout srcImageLayout,
-    VkImage destImage,
-    VkImageLayout destImageLayout,
+    VkImage dstImage,
+    VkImageLayout dstImageLayout,
     uint32_t regionCount,
     const VkImageResolve* pRegions)
 {
-    PreCmdResolveImage(cmdBuffer, pRegions);
+    PreCmdResolveImage(commandBuffer, pRegions);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 
-    PostCmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount);
+    PostCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount);
 }
 
 bool PostCmdSetEvent(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkEvent event,
     VkPipelineStageFlags stageMask)
 {
@@ -6041,17 +6041,17 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkEvent event,
     VkPipelineStageFlags stageMask)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdSetEvent(cmdBuffer, event, stageMask);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask);
 
-    PostCmdSetEvent(cmdBuffer, event, stageMask);
+    PostCmdSetEvent(commandBuffer, event, stageMask);
 }
 
 bool PostCmdResetEvent(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkEvent event,
     VkPipelineStageFlags stageMask)
 {
@@ -6062,25 +6062,25 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkEvent event,
     VkPipelineStageFlags stageMask)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResetEvent(cmdBuffer, event, stageMask);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask);
 
-    PostCmdResetEvent(cmdBuffer, event, stageMask);
+    PostCmdResetEvent(commandBuffer, event, stageMask);
 }
 
 bool PreCmdWaitEvents(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkEvent* pEvents,
-    const void* const* ppMemBarriers)
+    const void* const* ppMemoryBarriers)
 {
     if(pEvents != nullptr)
     {
     }
 
-    if(ppMemBarriers != nullptr)
+    if(ppMemoryBarriers != nullptr)
     {
     }
 
@@ -6088,11 +6088,11 @@
 }
 
 bool PostCmdWaitEvents(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     uint32_t eventCount,
     VkPipelineStageFlags srcStageMask,
-    VkPipelineStageFlags destStageMask,
-    uint32_t memBarrierCount)
+    VkPipelineStageFlags dstStageMask,
+    uint32_t memoryBarrierCount)
 {
 
 
@@ -6103,26 +6103,26 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     uint32_t eventCount,
     const VkEvent* pEvents,
     VkPipelineStageFlags srcStageMask,
-    VkPipelineStageFlags destStageMask,
-    uint32_t memBarrierCount,
-    const void* const* ppMemBarriers)
+    VkPipelineStageFlags dstStageMask,
+    uint32_t memoryBarrierCount,
+    const void* const* ppMemoryBarriers)
 {
-    PreCmdWaitEvents(cmdBuffer, pEvents, ppMemBarriers);
+    PreCmdWaitEvents(commandBuffer, pEvents, ppMemoryBarriers);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdWaitEvents(cmdBuffer, eventCount, pEvents, srcStageMask, destStageMask, memBarrierCount, ppMemBarriers);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers);
 
-    PostCmdWaitEvents(cmdBuffer, eventCount, srcStageMask, destStageMask, memBarrierCount);
+    PostCmdWaitEvents(commandBuffer, eventCount, srcStageMask, dstStageMask, memoryBarrierCount);
 }
 
 bool PreCmdPipelineBarrier(
-    VkCmdBuffer cmdBuffer,
-    const void* const* ppMemBarriers)
+    VkCommandBuffer commandBuffer,
+    const void* const* ppMemoryBarriers)
 {
-    if(ppMemBarriers != nullptr)
+    if(ppMemoryBarriers != nullptr)
     {
     }
 
@@ -6130,11 +6130,11 @@
 }
 
 bool PostCmdPipelineBarrier(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkPipelineStageFlags srcStageMask,
-    VkPipelineStageFlags destStageMask,
+    VkPipelineStageFlags dstStageMask,
     VkDependencyFlags dependencyFlags,
-    uint32_t memBarrierCount)
+    uint32_t memoryBarrierCount)
 {
 
 
@@ -6145,22 +6145,22 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkPipelineStageFlags srcStageMask,
-    VkPipelineStageFlags destStageMask,
+    VkPipelineStageFlags dstStageMask,
     VkDependencyFlags dependencyFlags,
-    uint32_t memBarrierCount,
-    const void* const* ppMemBarriers)
+    uint32_t memoryBarrierCount,
+    const void* const* ppMemoryBarriers)
 {
-    PreCmdPipelineBarrier(cmdBuffer, ppMemBarriers);
+    PreCmdPipelineBarrier(commandBuffer, ppMemoryBarriers);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, dependencyFlags, memBarrierCount, ppMemBarriers);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers);
 
-    PostCmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, dependencyFlags, memBarrierCount);
+    PostCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount);
 }
 
 bool PostCmdBeginQuery(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkQueryPool queryPool,
     uint32_t slot,
     VkQueryControlFlags flags)
@@ -6173,18 +6173,18 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkQueryPool queryPool,
     uint32_t slot,
     VkQueryControlFlags flags)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
 
-    PostCmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+    PostCmdBeginQuery(commandBuffer, queryPool, slot, flags);
 }
 
 bool PostCmdEndQuery(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkQueryPool queryPool,
     uint32_t slot)
 {
@@ -6195,17 +6195,17 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkQueryPool queryPool,
     uint32_t slot)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdEndQuery(cmdBuffer, queryPool, slot);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdEndQuery(commandBuffer, queryPool, slot);
 
-    PostCmdEndQuery(cmdBuffer, queryPool, slot);
+    PostCmdEndQuery(commandBuffer, queryPool, slot);
 }
 
 bool PostCmdResetQueryPool(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkQueryPool queryPool,
     uint32_t startQuery,
     uint32_t queryCount)
@@ -6218,18 +6218,18 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkQueryPool queryPool,
     uint32_t startQuery,
     uint32_t queryCount)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
 
-    PostCmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+    PostCmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
 }
 
 bool PostCmdWriteTimestamp(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkPipelineStageFlagBits pipelineStage,
     VkQueryPool queryPool,
     uint32_t slot)
@@ -6241,23 +6241,23 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkPipelineStageFlagBits pipelineStage,
     VkQueryPool queryPool,
     uint32_t slot)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
 
-    PostCmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
+    PostCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
 }
 
 bool PostCmdCopyQueryPoolResults(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkQueryPool queryPool,
     uint32_t startQuery,
     uint32_t queryCount,
-    VkBuffer destBuffer,
-    VkDeviceSize destOffset,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
     VkDeviceSize stride,
     VkQueryResultFlags flags)
 {
@@ -6273,22 +6273,22 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkQueryPool queryPool,
     uint32_t startQuery,
     uint32_t queryCount,
-    VkBuffer destBuffer,
-    VkDeviceSize destOffset,
+    VkBuffer dstBuffer,
+    VkDeviceSize dstOffset,
     VkDeviceSize stride,
     VkQueryResultFlags flags)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, stride, flags);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, stride, flags);
 
-    PostCmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, stride, flags);
+    PostCmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, stride, flags);
 }
 
 bool PreCmdPushConstants(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const void* values)
 {
     if(values != nullptr)
@@ -6299,7 +6299,7 @@
 }
 
 bool PostCmdPushConstants(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkPipelineLayout layout,
     VkShaderStageFlags stageFlags,
     uint32_t offset,
@@ -6314,29 +6314,29 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdPushConstants(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkPipelineLayout layout,
     VkShaderStageFlags stageFlags,
     uint32_t offset,
     uint32_t size,
     const void* values)
 {
-    PreCmdPushConstants(cmdBuffer, values);
+    PreCmdPushConstants(commandBuffer, values);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdPushConstants(cmdBuffer, layout, stageFlags, offset, size, values);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, values);
 
-    PostCmdPushConstants(cmdBuffer, layout, stageFlags, offset, size);
+    PostCmdPushConstants(commandBuffer, layout, stageFlags, offset, size);
 }
 
 bool PreCmdBeginRenderPass(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkRenderPassBeginInfo* pRenderPassBegin)
 {
     if(pRenderPassBegin != nullptr)
     {
     if(pRenderPassBegin->sType != VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdBeginRenderPass parameter, VkStructureType pRenderPassBegin->sType, is an invalid enumerator");
         return false;
     }
@@ -6349,14 +6349,14 @@
 }
 
 bool PostCmdBeginRenderPass(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkRenderPassContents contents)
 {
 
     if(contents < VK_RENDER_PASS_CONTENTS_BEGIN_RANGE ||
         contents > VK_RENDER_PASS_CONTENTS_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdBeginRenderPass parameter, VkRenderPassContents contents, is an unrecognized enumerator");
         return false;
     }
@@ -6365,26 +6365,26 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     const VkRenderPassBeginInfo* pRenderPassBegin,
     VkRenderPassContents contents)
 {
-    PreCmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
+    PreCmdBeginRenderPass(commandBuffer, pRenderPassBegin);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
 
-    PostCmdBeginRenderPass(cmdBuffer, contents);
+    PostCmdBeginRenderPass(commandBuffer, contents);
 }
 
 bool PostCmdNextSubpass(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkRenderPassContents contents)
 {
 
     if(contents < VK_RENDER_PASS_CONTENTS_BEGIN_RANGE ||
         contents > VK_RENDER_PASS_CONTENTS_END_RANGE)
     {
-        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
+        log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCmdNextSubpass parameter, VkRenderPassContents contents, is an unrecognized enumerator");
         return false;
     }
@@ -6393,34 +6393,34 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(
-    VkCmdBuffer cmdBuffer,
+    VkCommandBuffer commandBuffer,
     VkRenderPassContents contents)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdNextSubpass(cmdBuffer, contents);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdNextSubpass(commandBuffer, contents);
 
-    PostCmdNextSubpass(cmdBuffer, contents);
+    PostCmdNextSubpass(commandBuffer, contents);
 }
 
 bool PostCmdEndRenderPass(
-    VkCmdBuffer cmdBuffer)
+    VkCommandBuffer commandBuffer)
 {
 
     return true;
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(
-    VkCmdBuffer cmdBuffer)
+    VkCommandBuffer commandBuffer)
 {
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdEndRenderPass(cmdBuffer);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdEndRenderPass(commandBuffer);
 
-    PostCmdEndRenderPass(cmdBuffer);
+    PostCmdEndRenderPass(commandBuffer);
 }
 
 bool PreCmdExecuteCommands(
-    VkCmdBuffer cmdBuffer,
-    const VkCmdBuffer* pCmdBuffers)
+    VkCommandBuffer commandBuffer,
+    const VkCommandBuffer* pCommandBuffers)
 {
-    if(pCmdBuffers != nullptr)
+    if(pCommandBuffers != nullptr)
     {
     }
 
@@ -6428,8 +6428,8 @@
 }
 
 bool PostCmdExecuteCommands(
-    VkCmdBuffer cmdBuffer,
-    uint32_t cmdBuffersCount)
+    VkCommandBuffer commandBuffer,
+    uint32_t commandBuffersCount)
 {
 
 
@@ -6437,15 +6437,15 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdExecuteCommands(
-    VkCmdBuffer cmdBuffer,
-    uint32_t cmdBuffersCount,
-    const VkCmdBuffer* pCmdBuffers)
+    VkCommandBuffer commandBuffer,
+    uint32_t commandBuffersCount,
+    const VkCommandBuffer* pCommandBuffers)
 {
-    PreCmdExecuteCommands(cmdBuffer, pCmdBuffers);
+    PreCmdExecuteCommands(commandBuffer, pCommandBuffers);
 
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
+    get_dispatch_table(pc_device_table_map, commandBuffer)->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
 
-    PostCmdExecuteCommands(cmdBuffer, cmdBuffersCount);
+    PostCmdExecuteCommands(commandBuffer, commandBuffersCount);
 }
 
 VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
@@ -6472,8 +6472,8 @@
         return (PFN_vkVoidFunction) vkQueueWaitIdle;
     if (!strcmp(funcName, "vkDeviceWaitIdle"))
         return (PFN_vkVoidFunction) vkDeviceWaitIdle;
-    if (!strcmp(funcName, "vkAllocMemory"))
-        return (PFN_vkVoidFunction) vkAllocMemory;
+    if (!strcmp(funcName, "vkAllocateMemory"))
+        return (PFN_vkVoidFunction) vkAllocateMemory;
     if (!strcmp(funcName, "vkMapMemory"))
         return (PFN_vkVoidFunction) vkMapMemory;
     if (!strcmp(funcName, "vkFlushMappedMemoryRanges"))
@@ -6530,8 +6530,8 @@
         return (PFN_vkVoidFunction) vkCreateDescriptorPool;
     if (!strcmp(funcName, "vkResetDescriptorPool"))
         return (PFN_vkVoidFunction) vkResetDescriptorPool;
-    if (!strcmp(funcName, "vkAllocDescriptorSets"))
-        return (PFN_vkVoidFunction) vkAllocDescriptorSets;
+    if (!strcmp(funcName, "vkAllocateDescriptorSets"))
+        return (PFN_vkVoidFunction) vkAllocateDescriptorSets;
     if (!strcmp(funcName, "vkCmdSetViewport"))
         return (PFN_vkVoidFunction) vkCmdSetViewport;
     if (!strcmp(funcName, "vkCmdSetScissor"))
@@ -6550,8 +6550,8 @@
         return (PFN_vkVoidFunction) vkCmdSetStencilWriteMask;
     if (!strcmp(funcName, "vkCmdSetStencilReference"))
         return (PFN_vkVoidFunction) vkCmdSetStencilReference;
-    if (!strcmp(funcName, "vkAllocCommandBuffers"))
-        return (PFN_vkVoidFunction) vkAllocCommandBuffers;
+    if (!strcmp(funcName, "vkAllocateCommandBuffers"))
+        return (PFN_vkVoidFunction) vkAllocateCommandBuffers;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
         return (PFN_vkVoidFunction) vkBeginCommandBuffer;
     if (!strcmp(funcName, "vkEndCommandBuffer"))
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index 26bd8a3..6a85aeb 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -74,11 +74,11 @@
 } ImageMapStruct;
 static unordered_map<VkImage, ImageMapStruct *> imageMap;
 
-// unordered map: associates a device with a queue, cmdPool, and physical device
+// unordered map: associates a device with a queue, commandPool, and physical device
 typedef struct
 {
     VkQueue  queue;
-    VkCmdPool cmdPool;
+    VkCommandPool commandPool;
     VkPhysicalDevice physicalDevice;
 } DeviceMapStruct;
 static unordered_map<VkDevice, DeviceMapStruct *> deviceMap;
@@ -139,7 +139,7 @@
     int x, y;
     const char *ptr;
     VkDeviceMemory mem2;
-    VkCmdBuffer cmdBuffer;
+    VkCommandBuffer commandBuffer;
     VkDevice device = imageMap[image1]->device;
     VkPhysicalDevice physicalDevice = deviceMap[device]->physicalDevice;
     VkInstance instance = physDeviceMap[physicalDevice]->instance;
@@ -160,25 +160,25 @@
         1,
         1,
         VK_IMAGE_TILING_LINEAR,
-        (VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT|VK_IMAGE_USAGE_STORAGE_BIT),
+        (VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_STORAGE_BIT),
     };
-    VkMemoryAllocInfo memAllocInfo = {
+    VkMemoryAllocateInfo memAllocInfo = {
         VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
         NULL,
         0,     // allocationSize, queried later
         0      // memoryTypeIndex, queried later
     };
-    const VkCmdBufferAllocInfo allocCommandBufferInfo = {
-        VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO,
+    const VkCommandBufferAllocateInfo allocCommandBufferInfo = {
+        VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO,
         NULL,
-        deviceMap[device]->cmdPool,
-        VK_CMD_BUFFER_LEVEL_PRIMARY,
+        deviceMap[device]->commandPool,
+        VK_COMMAND_BUFFER_LEVEL_PRIMARY,
         1
     };
-    const VkCmdBufferBeginInfo cmdBufferBeginInfo = {
-        VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
+    const VkCommandBufferBeginInfo commandBufferBeginInfo = {
+        VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
         NULL,
-        VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+        VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
     };
     const VkImageCopy imageCopyRegion = {
         {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0},
@@ -193,7 +193,7 @@
     VkLayerDispatchTable* pTableDevice = get_dispatch_table(screenshot_device_table_map, device);
     VkLayerDispatchTable* pTableQueue = get_dispatch_table(screenshot_device_table_map, queue);
     VkLayerInstanceDispatchTable* pInstanceTable;
-    VkLayerDispatchTable* pTableCmdBuffer;
+    VkLayerDispatchTable* pTableCommandBuffer;
     VkPhysicalDeviceMemoryProperties memory_properties;
 
     if (imageMap.empty() || imageMap.find(image1) == imageMap.end())
@@ -222,26 +222,26 @@
                                 &memAllocInfo.memoryTypeIndex);
     assert(pass);
 
-    err = pTableDevice->AllocMemory(device, &memAllocInfo, NULL, &mem2);
+    err = pTableDevice->AllocateMemory(device, &memAllocInfo, NULL, &mem2);
     assert(!err);
 
     err = pTableQueue->BindImageMemory(device, image2, mem2, 0);
     assert(!err);
 
-    err = pTableDevice->AllocCommandBuffers(device, &allocCommandBufferInfo,  &cmdBuffer);
+    err = pTableDevice->AllocateCommandBuffers(device, &allocCommandBufferInfo,  &commandBuffer);
     assert(!err);
 
-    screenshot_device_table_map.emplace(cmdBuffer, pTableDevice);
-    pTableCmdBuffer = screenshot_device_table_map[cmdBuffer];
+    screenshot_device_table_map.emplace(commandBuffer, pTableDevice);
+    pTableCommandBuffer = screenshot_device_table_map[commandBuffer];
 
-    err = pTableCmdBuffer->BeginCommandBuffer(cmdBuffer, &cmdBufferBeginInfo);
+    err = pTableCommandBuffer->BeginCommandBuffer(commandBuffer, &commandBufferBeginInfo);
     assert(!err);
 
     // TODO: We need to transition images to match these layouts, then restore the original layouts
-    pTableCmdBuffer->CmdCopyImage(cmdBuffer, image1, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
-                   image2, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, 1, &imageCopyRegion);
+    pTableCommandBuffer->CmdCopyImage(commandBuffer, image1, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                   image2, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageCopyRegion);
 
-    err = pTableCmdBuffer->EndCommandBuffer(cmdBuffer);
+    err = pTableCommandBuffer->EndCommandBuffer(commandBuffer);
     assert(!err);
 
     VkFence nullFence = { VK_NULL_HANDLE };
@@ -251,7 +251,7 @@
     submit_info.waitSemaphoreCount = 0;
     submit_info.pWaitSemaphores = NULL;
     submit_info.commandBufferCount = 1;
-    submit_info.pCommandBuffers = &cmdBuffer;
+    submit_info.pCommandBuffers = &commandBuffer;
     submit_info.signalSemaphoreCount = 0;
     submit_info.pSignalSemaphores = NULL;
 
@@ -309,7 +309,7 @@
     // Clean up
     pTableDevice->UnmapMemory(device, mem2);
     pTableDevice->FreeMemory(device, mem2, NULL);
-    pTableDevice->FreeCommandBuffers(device, deviceMap[device]->cmdPool, 1, &cmdBuffer);
+    pTableDevice->FreeCommandBuffers(device, deviceMap[device]->commandPool, 1, &commandBuffer);
 }
 
 
@@ -336,7 +336,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice          gpu,
     const VkDeviceCreateInfo *pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkDevice                 *pDevice)
 {
     VkLayerDispatchTable *pDisp  = get_dispatch_table(screenshot_device_table_map, *pDevice);
@@ -461,12 +461,12 @@
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(
     VkDevice  device,
-    const VkCmdPoolCreateInfo *pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
-    VkCmdPool *pCmdPool)
+    const VkCommandPoolCreateInfo *pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkCommandPool *pCommandPool)
 {
     VkLayerDispatchTable* pTable = screenshot_device_table_map[device];
-    VkResult result = get_dispatch_table(screenshot_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
+    VkResult result = get_dispatch_table(screenshot_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
 
     loader_platform_thread_lock_mutex(&globalLock);
     if (screenshotEnvQueried && screenshotFrames.empty()) {
@@ -475,13 +475,13 @@
         return result;
     }
 
-    // Create a mapping from a device to a cmdPool
+    // Create a mapping from a device to a commandPool
     if (deviceMap[device] == NULL)
     {
         DeviceMapStruct *deviceMapElem = new DeviceMapStruct;
         deviceMap[device] = deviceMapElem;
     }
-    deviceMap[device]->cmdPool = *pCmdPool;
+    deviceMap[device]->commandPool = *pCommandPool;
     loader_platform_thread_unlock_mutex(&globalLock);
     return result;
 }
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 9e417f6..d7a9aa9 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -138,7 +138,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
     VkDevice device,
     const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
-    const VkAllocCallbacks* pAllocator,
+    const VkAllocationCallbacks* pAllocator,
     VkDescriptorSetLayout* pSetLayout)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -159,7 +159,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
     VkDevice                                    device,
     const VkPipelineLayoutCreateInfo*           pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkPipelineLayout*                           pPipelineLayout)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -604,7 +604,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateShaderModule(
         VkDevice device,
         const VkShaderModuleCreateInfo *pCreateInfo,
-        const VkAllocCallbacks* pAllocator,
+        const VkAllocationCallbacks* pAllocator,
         VkShaderModule *pShaderModule)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -629,7 +629,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
         VkDevice device,
         const VkShaderCreateInfo *pCreateInfo,
-        const VkAllocCallbacks* pAllocator,
+        const VkAllocationCallbacks* pAllocator,
         VkShader *pShader)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -644,7 +644,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
         VkDevice device,
         const VkRenderPassCreateInfo *pCreateInfo,
-        const VkAllocCallbacks* pAllocator,
+        const VkAllocationCallbacks* pAllocator,
         VkRenderPass *pRenderPass)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1135,7 +1135,7 @@
                          VkPipelineCache pipelineCache,
                          uint32_t count,
                          const VkGraphicsPipelineCreateInfo *pCreateInfos,
-                         const VkAllocCallbacks* pAllocator,
+                         const VkAllocationCallbacks* pAllocator,
                          VkPipeline *pPipelines)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1156,7 +1156,7 @@
 }
 
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
 {
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
     VkResult result = my_device_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
@@ -1168,7 +1168,7 @@
 }
 
 /* hook DextroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(device);
     layer_data *my_device_data = get_my_data_ptr(key, layer_data_map);
@@ -1179,7 +1179,7 @@
 
 VkResult VKAPI vkCreateInstance(
     const VkInstanceCreateInfo*                 pCreateInfo,
-    const VkAllocCallbacks*                     pAllocator,
+    const VkAllocationCallbacks*                     pAllocator,
     VkInstance*                                 pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -1200,7 +1200,7 @@
 }
 
 /* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(instance);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 0075b6f..7f428b8 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -197,7 +197,7 @@
 }
 
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
     // Call down the call chain:
@@ -218,7 +218,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
 {
     VkBool32 skipCall = VK_FALSE;
     dispatch_key key = get_dispatch_key(instance);
@@ -299,7 +299,7 @@
     return VK_ERROR_VALIDATION_FAILED;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
 {
     VkResult result = VK_SUCCESS;
     VkBool32 skipCall = VK_FALSE;
@@ -329,7 +329,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
 {
     VkBool32 skipCall = VK_FALSE;
     dispatch_key key = get_dispatch_key(device);
diff --git a/layers/swapchain.h b/layers/swapchain.h
index cc9e501..8d104e8 100644
--- a/layers/swapchain.h
+++ b/layers/swapchain.h
@@ -40,7 +40,7 @@
     {
         "Swapchain",
         VK_API_VERSION,                 // specVersion
-        VK_MAKE_VERSION(0, 1, 0),       // implVersion
+        VK_MAKE_VERSION(0, 1, 0),       // implementationVersion
         "layer: Swapchain",
     }
 };
@@ -49,7 +49,7 @@
     {
         "Swapchain",
         VK_API_VERSION,                 // specVersion
-        VK_MAKE_VERSION(0, 1, 0),       // implVersion
+        VK_MAKE_VERSION(0, 1, 0),       // implementationVersion
         "layer: Swapchain",
     }
 };
diff --git a/layers/vk_layer_debug_marker_table.cpp b/layers/vk_layer_debug_marker_table.cpp
index b3b54c1..fbfe9a2 100644
--- a/layers/vk_layer_debug_marker_table.cpp
+++ b/layers/vk_layer_debug_marker_table.cpp
@@ -30,7 +30,7 @@
  * are created from that "parent" object. Thus use pointer to dispatch table
  * as the key to these table maps.
  *    Instance -> PhysicalDevice
- *    Device -> CmdBuffer or Queue
+ *    Device -> CommandBuffer or Queue
  * If use the object themselves as key to map then implies Create entrypoints have to be intercepted
  * and a new key inserted into map */
 VkLayerDebugMarkerDispatchTable * initDebugMarkerTable(VkDevice device)
diff --git a/layers/vk_layer_table.cpp b/layers/vk_layer_table.cpp
index cbe80be..67217ff 100644
--- a/layers/vk_layer_table.cpp
+++ b/layers/vk_layer_table.cpp
@@ -128,7 +128,7 @@
  * are created from that "parent" object. Thus use pointer to dispatch table
  * as the key to these table maps.
  *    Instance -> PhysicalDevice
- *    Device -> CmdBuffer or Queue
+ *    Device -> CommandBuffer or Queue
  * If use the object themselves as key to map then implies Create entrypoints have to be intercepted
  * and a new key inserted into map */
 VkLayerInstanceDispatchTable * initInstanceTable(instance_table_map &map, const VkBaseLayerObject *instancew)
diff --git a/layers/vk_layer_utils.cpp b/layers/vk_layer_utils.cpp
index b0a483a..3fbf7e1 100644
--- a/layers/vk_layer_utils.cpp
+++ b/layers/vk_layer_utils.cpp
@@ -35,7 +35,7 @@
 
 // Set up data structure with number of bytes and number of channels
 // for each Vulkan format.
-static const VULKAN_FORMAT_INFO vk_format_table[VK_FORMAT_NUM] = {
+static const VULKAN_FORMAT_INFO vk_format_table[VK_FORMAT_RANGE_SIZE] = {
     { 0,  0 }, //    [VK_FORMAT_UNDEFINED]
     { 1,  2 }, //    [VK_FORMAT_R4G4_UNORM]
     { 1,  2 }, //    [VK_FORMAT_R4G4_USCALED]
diff --git a/layers/vk_validation_layer_details.md b/layers/vk_validation_layer_details.md
index bbeb0fa..f13c2b0 100644
--- a/layers/vk_validation_layer_details.md
+++ b/layers/vk_validation_layer_details.md
@@ -14,24 +14,24 @@
 | ----- | -------- | ---------------- | ------------ | -------- | ---------- |
 | Valid Pipeline Layouts | Validates that pipeline layout from bound descriptor set matches the current pipeline layout | PIPELINE_LAYOUT_MISMATCH | vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect | TBD | None |
 | Validate DbgMarker exensions | Validates that DbgMarker extensions have been enabled before use | INVALID_EXTENSION | vkCmdDbgMarkerBegin vkCmdDbgMarkerEnd | TBD | None |
-| Valid BeginCommandBuffer level-related parameters | Primary command buffers must specify VK_NULL_HANDLE for RenderPass or Framebuffer parameters, while secondary command buffers must provide non-null parameters | BEGIN_CB_INVALID_STATE | vkBeginCommandBuffer | PrimaryCmdBufferFramebufferAndRenderpass SecondaryCmdBufferFramebufferAndRenderpass | None |
-| PSO Bound | Verify that a properly created and valid pipeline object is bound to the CmdBuffer specified in these calls | NO_PIPELINE_BOUND | vkCmdBindDescriptorSets vkCmdBindVertexBuffers | PipelineNotBound | This check is currently more related to DrawState data structures and less about verifying that PSO is bound at all appropriate points in API. For API purposes, need to make sure this is checked at Draw time and any other relevant calls. |
-| Valid DescriptorPool | Verifies that the descriptor set pool object was properly created and is valid | INVALID_POOL | vkResetDescriptorPool vkAllocDescriptorSets | None | This is just an internal layer data structure check. ParamChecker or ObjectTracker should really catch bad DSPool |
+| Valid BeginCommandBuffer level-related parameters | Primary command buffers must specify VK_NULL_HANDLE for RenderPass or Framebuffer parameters, while secondary command buffers must provide non-null parameters | BEGIN_CB_INVALID_STATE | vkBeginCommandBuffer | PrimaryCommandBufferFramebufferAndRenderpass SecondaryCommandBufferFramebufferAndRenderpass | None |
+| PSO Bound | Verify that a properly created and valid pipeline object is bound to the CommandBuffer specified in these calls | NO_PIPELINE_BOUND | vkCmdBindDescriptorSets vkCmdBindVertexBuffers | PipelineNotBound | This check is currently more related to DrawState data structures and less about verifying that PSO is bound at all appropriate points in API. For API purposes, need to make sure this is checked at Draw time and any other relevant calls. |
+| Valid DescriptorPool | Verifies that the descriptor set pool object was properly created and is valid | INVALID_POOL | vkResetDescriptorPool vkAllocateDescriptorSets | None | This is just an internal layer data structure check. ParamChecker or ObjectTracker should really catch bad DSPool |
 | Valid DescriptorSet | Validate that descriptor set was properly created and is currently valid | INVALID_SET | vkCmdBindDescriptorSets | None | Is this needed other places (like Update/Clear descriptors) |
-| Valid DescriptorSetLayout | Flag DescriptorSetLayout object that was not properly created | INVALID_LAYOUT | vkAllocDescriptorSets | None | Anywhere else to check this? |
+| Valid DescriptorSetLayout | Flag DescriptorSetLayout object that was not properly created | INVALID_LAYOUT | vkAllocateDescriptorSets | None | Anywhere else to check this? |
 | Valid Pipeline | Flag VkPipeline object that was not properly created | INVALID_PIPELINE | vkCmdBindPipeline | InvalidPipeline | NA |
 | Valid Pipeline Create Info | Tests for the following: That compute shaders are not specified for the graphics pipeline, tess evaluation and tess control shaders are included or excluded as a pair, that VK_PRIMITIVE_TOPOLOGY_PATCH is set as IA topology for tessellation pipelines, that VK_PRIMITIVE_TOPOLOGY_PATCH primitive topology is only set for tessellation pipelines, and that Vtx Shader specified | INVALID_PIPELINE_CREATE_STATE | vkCreateGraphicsPipelines | InvalidPipelineCreateState | NA |
-| Valid CmdBuffer | Validates that the command buffer object was properly created and is currently valid | INVALID_CMD_BUFFER | vkQueueSubmit vkBeginCommandBuffer vkEndCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands vkCmdDbgMarkerBegin vkCmdDbgMarkerEnd vkAllocCommandBuffers | None | NA |
+| Valid CommandBuffer | Validates that the command buffer object was properly created and is currently valid | INVALID_COMMAND_BUFFER | vkQueueSubmit vkBeginCommandBuffer vkEndCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands vkCmdDbgMarkerBegin vkCmdDbgMarkerEnd vkAllocateCommandBuffers | None | NA |
 | Vtx Buffer Bounds | Check if VBO index too large for PSO Vtx binding count, and that at least one vertex buffer is attached to pipeline object | VTX_INDEX_OUT_OF_BOUNDS | vkCmdBindDescriptorSets vkCmdBindVertexBuffers | VtxBufferBadIndex | NA |
 | Idx Buffer Alignment | Verify that offset of Index buffer falls on an alignment boundary as defined by IdxBufferAlignmentError param | VTX_INDEX_ALIGNMENT_ERROR | vkCmdBindIndexBuffer | IdxBufferAlignmentError | NA |
-| Cmd Buffer End | Verifies that EndCommandBuffer was called for this cmdBuffer at QueueSubmit time | NO_END_CMD_BUFFER | vkQueueSubmit | NoEndCmdBuffer | NA |
-| Cmd Buffer Begin | Check that BeginCommandBuffer was called for this command buffer when binding commands or calling end | NO_BEGIN_CMD_BUFFER | vkEndCommandBuffer vkCmdBindPipeline vkCmdSetViewport vkCmdSetLineWidth vkCmdSetDepthBias vkCmdSetBlendConstants vkCmdSetDepthBounds vkCmdSetStencilCompareMask vkCmdSetStencilWriteMask vkCmdSetStencilReference vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp | NoBeginCmdBuffer | NA |
-| Cmd Buffer Submit Count | Verify that ONE_TIME submit cmdbuffer is not submitted multiple times | CMD_BUFFER_SINGLE_SUBMIT_VIOLATION | vkBeginCommandBuffer, vkQueueSubmit | CmdBufferTwoSubmits | NA |
-| Valid Secondary CmdBuffer | Validates that no primary command buffers are sent to vkCmdExecuteCommands() are | INVALID_SECONDARY_CMD_BUFFER | vkCmdExecuteCommands | ExecuteCommandsPrimaryCB | NA |
+| Cmd Buffer End | Verifies that EndCommandBuffer was called for this commandBuffer at QueueSubmit time | NO_END_COMMAND_BUFFER | vkQueueSubmit | NoEndCommandBuffer | NA |
+| Cmd Buffer Begin | Check that BeginCommandBuffer was called for this command buffer when binding commands or calling end | NO_BEGIN_COMMAND_BUFFER | vkEndCommandBuffer vkCmdBindPipeline vkCmdSetViewport vkCmdSetLineWidth vkCmdSetDepthBias vkCmdSetBlendConstants vkCmdSetDepthBounds vkCmdSetStencilCompareMask vkCmdSetStencilWriteMask vkCmdSetStencilReference vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp | NoBeginCommandBuffer | NA |
+| Cmd Buffer Submit Count | Verify that ONE_TIME submit cmdbuffer is not submitted multiple times | COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION | vkBeginCommandBuffer, vkQueueSubmit | CommandBufferTwoSubmits | NA |
+| Valid Secondary CommandBuffer | Validates that no primary command buffers are sent to vkCmdExecuteCommands() are | INVALID_SECONDARY_COMMAND_BUFFER | vkCmdExecuteCommands | ExecuteCommandsPrimaryCB | NA |
 | Descriptor Type | Verify Descriptor type in bound descriptor set layout matches descriptor type specified in update. This also includes mismatches in the TYPES of copied descriptors. | DESCRIPTOR_TYPE_MISMATCH | vkUpdateDescriptorSets | DSTypeMismatch CopyDescriptorUpdateErrors | NA |
 | Descriptor StageFlags | Verify all descriptors within a single write update have the same stageFlags | DESCRIPTOR_STAGEFLAGS_MISMATCH | vkUpdateDescriptorSets | NONE | Test this case |
 | DS Update Size | DS update out of bounds for given layout section. | DESCRIPTOR_UPDATE_OUT_OF_BOUNDS | vkUpdateDescriptorSets | DSUpdateOutOfBounds CopyDescriptorUpdateErrors | NA |
-| Descriptor Pool empty | Attempt to allocate descriptor type from descriptor pool when no more of that type are available to be allocated. | DESCRIPTOR_POOL_EMPTY | vkAllocDescriptorSets | AllocDescriptorFromEmptyPool | NA |
+| Descriptor Pool empty | Attempt to allocate descriptor type from descriptor pool when no more of that type are available to be allocated. | DESCRIPTOR_POOL_EMPTY | vkAllocateDescriptorSets | AllocDescriptorFromEmptyPool | NA |
 | Free from NON_FREE Pool | It's invalid to call vkFreeDescriptorSets() on Sets that were allocated from a Pool created with NON_FREE usage. | CANT_FREE_FROM_NON_FREE_POOL | vkFreeDescriptorSets | None | NA |
 | DS Update Index | DS update binding too large for layout binding count. | INVALID_UPDATE_INDEX | vkUpdateDescriptorSets | InvalidDSUpdateIndex CopyDescriptorUpdateErrors | NA |
 | DS Update Type | Verifies that structs in DS Update tree are properly created, currenly valid, and of the right type | INVALID_UPDATE_STRUCT | vkUpdateDescriptorSets | InvalidDSUpdateStruct | NA |
@@ -84,7 +84,7 @@
  26. vkFreeDescriptorSets must not be called for sets created on top of one-shot pool
  27. If Cmd Buffer one-time submit flag is set, then verify that cmd buffer is only submitted once
  28. Verify that all relevent dynamic state objects are bound (See https://cvs.khronos.org/bugzilla/show_bug.cgi?id=14323)
- 29. Flag an error if CmdBuffer has Begin called while it's being constructed - this is not a reset, this is a violation
+ 29. Flag an error if CommandBuffer has Begin called while it's being constructed - this is not a reset, this is a violation
  30. At PSO creation time, there is no case when NOT including a FS should flag an error since there exist dynamic state configurations that can be set to cause a FS to not be required. Instead, in the case when no FS is in the PSO, validation should detect at runtime if dynamic state will require a FS, and in those case issue a runtime warning about undefined behavior. (see bug https://cvs.khronos.org/bugzilla/show_bug.cgi?id=14429)
  31. Error if a cmdbuffer is submitted on a queue whose family doesn't match the family of the pool from which it was created.
  32. Update Gfx Pipe Create Info shadowing to remove new/delete and instead use unique_ptrs for auto clean-up
@@ -99,8 +99,8 @@
 
 | Check | Overview | ENUM | Relevant API | Testname | Notes/TODO |
 | ----- | -------- | ---------------- | ------------ | -------- | ---------- |
-| Input Parameters | Pointers in structures are recursively validated to be non-null. Enumerated types are validated against min and max enum values. Structure Types are verified to be correct. | NA | vkQueueSubmit vkAllocMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkQueueBindSparse vkCreateFence vkResetFences vkWaitForFences vkCreateSemaphore vkCreateEvent vkCreateQueryPool vkCreateBuffer vkCreateBufferView vkCreateImage vkGetImageSubresourceLayout vkCreateImageView vkCreateShader vkCreatePipelineCache vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkCreatePipelineLayout vkCreateSampler vkCreateDescriptorSetLayout( vkCreateDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkCreateRenderPass vkCreateCommandPool vkAllocCommandBuffers vkBeginCommandBuffer vkCmdBindDescriptorSets vkCmdBindVertexBuffers vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdWaitEvents vkCmdPipelineBarrier vkCmdPushConstants vkCmdBeginRenderPass vkCmdExecuteCommands | TBD | NA |
-| Call results, Output Parameters | Return values are checked for VK_SUCCESS, returned pointers are checked to be NON-NULL, enumerated types of return values are checked to be within the defined range. | NA | vkEnumeratePhysicalDevices vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceLimits vkGetPhysicalDeviceProperties vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceMemoryProperties vkGetDeviceQueue vkQueueSubmit vkQueueWaitIdle vkDeviceWaitIdle vkAllocMemory vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkGetDeviceMemoryCommitment vkBindBufferMemory vkBindImageMemory vkGetBufferMemoryRequirements vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetPhysicalDeviceSparseImageFormatProperties vkQueueBindSparse vkCreateFence vkDestroyFence vkResetFences vkGetFenceStatus vkWaitForFences vkCreateSemaphore vkDestroySemaphore vkCreateEvent vkDestroyEvent vkGetEventStatus vkSetEvent vkResetEvent vkCreateQueryPool vkDestroyQueryPool vkGetQueryPoolResults vkCreateBuffer vkDestroyBuffer vkCreateBufferView vkDestroyBufferView vkCreateImage vkDestroyImage vkGetImageSubresourceLayout vkCreateImageView vkDestroyImageView vkDestroyShaderModule vkCreateShader vkDestroyShader vkCreatePipelineCache vkDestroyPipelineCache vkGetPipelineCacheData vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkDestroyPipeline vkCreatePipelineLayout vkDestroyPipelineLayout vkCreateSampler vkDestroySampler vkCreateDescriptorSetLayout vkDestroyDescriptorSetLayout vkCreateDescriptorPool vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkDestroyFramebuffer vkCreateRenderPass vkDestroyRenderPass vkGetRenderAreaGranularity vkCreateCommandPool vkDestroyCommandPool vkResetCommandPool vkAllocCommandBuffers vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdPushConstants vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands | TBD | NA |
+| Input Parameters | Pointers in structures are recursively validated to be non-null. Enumerated types are validated against min and max enum values. Structure Types are verified to be correct. | NA | vkQueueSubmit vkAllocateMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkQueueBindSparse vkCreateFence vkResetFences vkWaitForFences vkCreateSemaphore vkCreateEvent vkCreateQueryPool vkCreateBuffer vkCreateBufferView vkCreateImage vkGetImageSubresourceLayout vkCreateImageView vkCreateShader vkCreatePipelineCache vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkCreatePipelineLayout vkCreateSampler vkCreateDescriptorSetLayout( vkCreateDescriptorPool vkAllocateDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkCreateRenderPass vkCreateCommandPool vkAllocateCommandBuffers vkBeginCommandBuffer vkCmdBindDescriptorSets vkCmdBindVertexBuffers vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdWaitEvents vkCmdPipelineBarrier vkCmdPushConstants vkCmdBeginRenderPass vkCmdExecuteCommands | TBD | NA |
+| Call results, Output Parameters | Return values are checked for VK_SUCCESS, returned pointers are checked to be NON-NULL, enumerated types of return values are checked to be within the defined range. | NA | vkEnumeratePhysicalDevices vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceLimits vkGetPhysicalDeviceProperties vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceMemoryProperties vkGetDeviceQueue vkQueueSubmit vkQueueWaitIdle vkDeviceWaitIdle vkAllocateMemory vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkGetDeviceMemoryCommitment vkBindBufferMemory vkBindImageMemory vkGetBufferMemoryRequirements vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetPhysicalDeviceSparseImageFormatProperties vkQueueBindSparse vkCreateFence vkDestroyFence vkResetFences vkGetFenceStatus vkWaitForFences vkCreateSemaphore vkDestroySemaphore vkCreateEvent vkDestroyEvent vkGetEventStatus vkSetEvent vkResetEvent vkCreateQueryPool vkDestroyQueryPool vkGetQueryPoolResults vkCreateBuffer vkDestroyBuffer vkCreateBufferView vkDestroyBufferView vkCreateImage vkDestroyImage vkGetImageSubresourceLayout vkCreateImageView vkDestroyImageView vkDestroyShaderModule vkCreateShader vkDestroyShader vkCreatePipelineCache vkDestroyPipelineCache vkGetPipelineCacheData vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkDestroyPipeline vkCreatePipelineLayout vkDestroyPipelineLayout vkCreateSampler vkDestroySampler vkCreateDescriptorSetLayout vkDestroyDescriptorSetLayout vkCreateDescriptorPool vkDestroyDescriptorPool vkResetDescriptorPool vkAllocateDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkDestroyFramebuffer vkCreateRenderPass vkDestroyRenderPass vkGetRenderAreaGranularity vkCreateCommandPool vkDestroyCommandPool vkResetCommandPool vkAllocateCommandBuffers vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdPushConstants vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands | TBD | NA |
 | NA | Enum used for informational messages | NONE | | NA | None |
 
 ### ParamChecker Pending Work
@@ -162,7 +162,7 @@
 | Bind Invalid Memory | Validate that memory object was correctly created, that the command buffer object was correctly created, and that both are currently valid objects. | MEMORY_BINDING_ERROR | vkQueueBindSparse vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage | NA | The valid Object checks are primarily the responsibilty of ObjectTracker layer, so these checks are more of a backup in case ObjectTracker is not enabled | 
 | Objects Not Destroyed | Verify all objects destroyed at DestroyDevice time | MEMORY_LEAK | vkDestroyDevice | NA | NA |
 | Memory Mapping State | Verifies that mapped memory is CPU-visible | INVALID_STATE | vkMapMemory | MapMemWithoutHostVisibleBit | NA |
-| Command Buffer Synchronization | Command Buffer must be complete before BeginCommandBuffer or ResetCommandBuffer can be called | RESET_CB_WHILE_IN_FLIGHT | vkBeginCommandBuffer vkResetCommandBuffer | CallBeginCmdBufferBeforeCompletion CallBeginCmdBufferBeforeCompletion | NA |
+| Command Buffer Synchronization | Command Buffer must be complete before BeginCommandBuffer or ResetCommandBuffer can be called | RESET_CB_WHILE_IN_FLIGHT | vkBeginCommandBuffer vkResetCommandBuffer | CallBeginCommandBufferBeforeCompletion CallBeginCommandBufferBeforeCompletion | NA |
 | Submitted Fence Status | Verifies that: The fence is not submitted in an already signaled state, that ResetFences is not called with a fence in an unsignaled state, and that fences being checked have been submitted | INVALID_FENCE_STATE | vkResetFences vkWaitForFences vkQueueSubmit vkGetFenceStatus | SubmitSignaledFence ResetUnsignaledFence | Create test(s) for case where an unsubmitted fence is having its status checked |
 | Immutable Memory Binding | Validates that non-sparse memory bindings are immutable, so objects are not re-boundt | REBIND_OBJECT | vkBindBufferMemory, vkBindImageMemory | RebindMemory | NA |
 | Image/Buffer Usage bits | Verify correct USAGE bits set based on how Images and Buffers are used | INVALID_USAGE_FLAG | vkCreateImage, vkCreateBuffer, vkCreateBufferView, vkCmdCopyBuffer, vkCmdCopyQueryPoolResults, vkCmdCopyImage, vkCmdBlitImage, vkCmdCopyBufferToImage, vkCmdCopyImageToBuffer, vkCmdUpdateBuffer, vkCmdFillBuffer  | InvalidUsageBits | NA |
@@ -226,7 +226,7 @@
 
 | Check | Overview | ENUM OBJTRACK_* | Relevant API | Testname | Notes/TODO |
 | ----- | -------- | ---------------- | ------------ | -------- | ---------- |
-| Valid Object | Validates that referenced object was properly created and is currently valid. | INVALID_OBJECT | vkAcquireNextImageKHR vkAllocDescriptorSets vkAllocMemory vkBeginCommandBuffer vkBindBufferMemory vkBindImageMemory vkCmdBeginQuery vkCmdBeginRenderPass vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindPipeline vkCmdBindVertexBuffers vkCmdBlitImage vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdCopyBuffer vkCmdCopyBufferToImage vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyQueryPoolResults vkCmdDispatch vkCmdDispatchIndirect vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndexedIndirect vkCmdDrawIndirect vkCmdEndQuery vkCmdEndRenderPass vkCmdExecuteCommands vkCmdFillBuffer vkCmdNextSubpass vkCmdPipelineBarrier vkCmdPushConstants vkCmdResetEvent vkCmdResetQueryPool vkCmdResolveImage vkCmdSetEvent vkCmdUpdateBuffer vkCmdWaitEvents vkCmdWriteTimestamp vkCreateBuffer vkCreateBufferView vkAllocCommandBuffers vkCreateCommandPool vkCreateComputePipelines vkCreateDescriptorPool vkCreateDescriptorSetLayout vkCreateEvent vkCreateFence vkCreateFramebuffer vkCreateGraphicsPipelines vkCreateImage vkCreateImageView vkCreatePipelineCache vkCreatePipelineLayout vkCreateQueryPool vkCreateRenderPass vkCreateSampler vkCreateSemaphore vkCreateShader vkCreateShaderModule vkCreateSwapchainKHR vkDestroyBuffer vkDestroyBufferView vkFreeCommandBuffers vkDestroyCommandPool vkDestroyDescriptorPool vkDestroyDescriptorSetLayout vkDestroyEvent vkDestroyFence vkDestroyFramebuffer vkDestroyImage vkDestroyImageView vkDestroyPipeline vkDestroyPipelineCache vkDestroyPipelineLayout vkDestroyQueryPool vkDestroyRenderPass vkDestroySampler vkDestroySemaphore vkDestroyShader vkDestroyShaderModule vkDestroySwapchainKHR vkDeviceWaitIdle vkEndCommandBuffer vkEnumeratePhysicalDevices vkFreeDescriptorSets vkFreeMemory vkFreeMemory vkGetBufferMemoryRequirements vkGetDeviceMemoryCommitment vkGetDeviceQueue vkGetEventStatus vkGetFenceStatus vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetImageSubresourceLayout vkGetPhysicalDeviceSurfaceSupportKHR vkGetPipelineCacheData vkGetQueryPoolResults vkGetRenderAreaGranularity vkInvalidateMappedMemoryRanges vkMapMemory vkMergePipelineCaches vkQueueBindSparse vkResetCommandBuffer vkResetCommandPool vkResetDescriptorPool vkResetEvent vkResetFences vkSetEvent vkUnmapMemory vkUpdateDescriptorSets vkWaitForFences | BindInvalidMemory BindMemoryToDestroyedObject | Every VkObject class of parameter will be run through this check. This check may ultimately supersede UNKNOWN_OBJECT |
+| Valid Object | Validates that referenced object was properly created and is currently valid. | INVALID_OBJECT | vkAcquireNextImageKHR vkAllocateDescriptorSets vkAllocateMemory vkBeginCommandBuffer vkBindBufferMemory vkBindImageMemory vkCmdBeginQuery vkCmdBeginRenderPass vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindPipeline vkCmdBindVertexBuffers vkCmdBlitImage vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdCopyBuffer vkCmdCopyBufferToImage vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyQueryPoolResults vkCmdDispatch vkCmdDispatchIndirect vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndexedIndirect vkCmdDrawIndirect vkCmdEndQuery vkCmdEndRenderPass vkCmdExecuteCommands vkCmdFillBuffer vkCmdNextSubpass vkCmdPipelineBarrier vkCmdPushConstants vkCmdResetEvent vkCmdResetQueryPool vkCmdResolveImage vkCmdSetEvent vkCmdUpdateBuffer vkCmdWaitEvents vkCmdWriteTimestamp vkCreateBuffer vkCreateBufferView vkAllocateCommandBuffers vkCreateCommandPool vkCreateComputePipelines vkCreateDescriptorPool vkCreateDescriptorSetLayout vkCreateEvent vkCreateFence vkCreateFramebuffer vkCreateGraphicsPipelines vkCreateImage vkCreateImageView vkCreatePipelineCache vkCreatePipelineLayout vkCreateQueryPool vkCreateRenderPass vkCreateSampler vkCreateSemaphore vkCreateShader vkCreateShaderModule vkCreateSwapchainKHR vkDestroyBuffer vkDestroyBufferView vkFreeCommandBuffers vkDestroyCommandPool vkDestroyDescriptorPool vkDestroyDescriptorSetLayout vkDestroyEvent vkDestroyFence vkDestroyFramebuffer vkDestroyImage vkDestroyImageView vkDestroyPipeline vkDestroyPipelineCache vkDestroyPipelineLayout vkDestroyQueryPool vkDestroyRenderPass vkDestroySampler vkDestroySemaphore vkDestroyShader vkDestroyShaderModule vkDestroySwapchainKHR vkDeviceWaitIdle vkEndCommandBuffer vkEnumeratePhysicalDevices vkFreeDescriptorSets vkFreeMemory vkFreeMemory vkGetBufferMemoryRequirements vkGetDeviceMemoryCommitment vkGetDeviceQueue vkGetEventStatus vkGetFenceStatus vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetImageSubresourceLayout vkGetPhysicalDeviceSurfaceSupportKHR vkGetPipelineCacheData vkGetQueryPoolResults vkGetRenderAreaGranularity vkInvalidateMappedMemoryRanges vkMapMemory vkMergePipelineCaches vkQueueBindSparse vkResetCommandBuffer vkResetCommandPool vkResetDescriptorPool vkResetEvent vkResetFences vkSetEvent vkUnmapMemory vkUpdateDescriptorSets vkWaitForFences | BindInvalidMemory BindMemoryToDestroyedObject | Every VkObject class of parameter will be run through this check. This check may ultimately supersede UNKNOWN_OBJECT |
 | Object Cleanup | Verify that object properly destroyed | DESTROY_OBJECT_FAILED | vkDestroyInstance, vkDestroyDevice, vkFreeMemory | ? | NA |
 | Objects Leak | When an Instance or Device object is destroyed, validates that all objects belonging to that device/instance have previously been destroyed | OBJECT_LEAK | vkDestroyDevice vkDestroyInstance | ? | NA |
 | Object Count | Flag error if number of objects requested from extenstion functions exceeds max number of actual objects | OBJCOUNT_MAX_EXCEEDED | objTrackGetObjects objTrackGetObjectsOfType | ? | NA |
@@ -253,8 +253,8 @@
 See [bug 13433](https://cvs.khronos.org/bugzilla/show_bug.cgi?id=13433) and
 <https://cvs.khronos.org/svn/repos/oglc/trunk/nextgen/vulkan/function_properties.csv>
 for threading rules.
-Objects that may need a mutex include VkQueue, VkDeviceMemory, VkObject, VkBuffer, VkImage, VkDescriptorSet, VkDescriptorPool, VkCmdBuffer, and VkSemaphore.
-The most common case is that a VkCmdBuffer passed to VkCmd* calls must be used by only one thread at a time.
+Objects that may need a mutex include VkQueue, VkDeviceMemory, VkObject, VkBuffer, VkImage, VkDescriptorSet, VkDescriptorPool, VkCommandBuffer, and VkSemaphore.
+The most common case is that a VkCommandBuffer passed to VkCmd* calls must be used by only one thread at a time.
 
 In addition to reporting threading rule violations, the layer will enforce a mutex for those calls.
 That can allow an application to continue running without actually crashing due to the reported threading problem.
@@ -273,8 +273,8 @@
 
 | Check | Overview | ENUM THREADING_CHECKER_* | Relevant API | Testname | Notes/TODO |
 | ----- | -------- | ---------------- | ---------------- | -------- | ---------- |
-| Thread Collision | Detects and notifies user if multiple threads are modifying thes same object | MULTIPLE_THREADS | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparse vkDestroySemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
-| Thread Reentrancy | Detects cases of a single thread calling Vulkan reentrantly | SINGLE_THREAD_REUSE | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparse vkDestroySemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdSetViewport vkCmdSetBlendConstants vkCmdSetLineWidth vkCmdSetDepthBias vkCmdSetDepthBounds vkCmdSetStencilCompareMask vkCmdSetStencilWriteMask vkCmdSetStencilReference vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
+| Thread Collision | Detects and notifies user if multiple threads are modifying thes same object | MULTIPLE_THREADS | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparse vkDestroySemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocateDescriptorSets vkFreeDescriptorSets vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
+| Thread Reentrancy | Detects cases of a single thread calling Vulkan reentrantly | SINGLE_THREAD_REUSE | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparse vkDestroySemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocateDescriptorSets vkFreeDescriptorSets vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdSetViewport vkCmdSetBlendConstants vkCmdSetLineWidth vkCmdSetDepthBias vkCmdSetDepthBounds vkCmdSetStencilCompareMask vkCmdSetStencilWriteMask vkCmdSetStencilReference vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
 | NA | Enum used for informational messages | NONE | | NA | None |
 
 ### Threading Pending Work
@@ -362,7 +362,7 @@
 
 ### APIDump Pending Work
 
- 1. vkAllocDescriptorSets does not correctly print out all of the created DescriptorSets (no array printing following main API txt)
+ 1. vkAllocateDescriptorSets does not correctly print out all of the created DescriptorSets (no array printing following main API txt)
 
 
 ## General Pending Work
diff --git a/loader/debug_report.c b/loader/debug_report.c
index c1cca4f..88c3fb0 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -42,7 +42,7 @@
 typedef void (VKAPI *PFN_stringCallback)(char *message);
 
 static const VkExtensionProperties debug_report_extension_info = {
-        .extName = VK_DEBUG_REPORT_EXTENSION_NAME,
+        .extensionName = VK_DEBUG_REPORT_EXTENSION_NAME,
         .specVersion = VK_DEBUG_REPORT_EXTENSION_REVISION,
 };
 
@@ -74,7 +74,7 @@
         void* pUserData,
         VkDbgMsgCallback* pMsgCallback)
 {
-    VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *) loader_heap_alloc((struct loader_instance *)instance, sizeof(VkLayerDbgFunctionNode), VK_SYSTEM_ALLOC_SCOPE_OBJECT);
+    VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *) loader_heap_alloc((struct loader_instance *)instance, sizeof(VkLayerDbgFunctionNode), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
     if (!pNewDbgFuncNode)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index f572c36..995d4f5 100644
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -73,8 +73,8 @@
         return (void*) vkQueueWaitIdle;
     if (!strcmp(name, "DeviceWaitIdle"))
         return (void*) vkDeviceWaitIdle;
-    if (!strcmp(name, "AllocMemory"))
-        return (void*) vkAllocMemory;
+    if (!strcmp(name, "AllocateMemory"))
+        return (void*) vkAllocateMemory;
     if (!strcmp(name, "FreeMemory"))
         return (void*) vkFreeMemory;
     if (!strcmp(name, "MapMemory"))
@@ -189,8 +189,8 @@
         return (void*) vkDestroyDescriptorPool;
     if (!strcmp(name, "ResetDescriptorPool"))
         return (void*) vkResetDescriptorPool;
-    if (!strcmp(name, "AllocDescriptorSets"))
-        return (void*) vkAllocDescriptorSets;
+    if (!strcmp(name, "AllocateDescriptorSets"))
+        return (void*) vkAllocateDescriptorSets;
     if (!strcmp(name, "FreeDescriptorSets"))
         return (void*) vkFreeDescriptorSets;
     if (!strcmp(name, "UpdateDescriptorSets"))
@@ -211,8 +211,8 @@
         return (void*) vkDestroyCommandPool;
     if (!strcmp(name, "ResetCommandPool"))
         return (void*) vkResetCommandPool;
-    if (!strcmp(name, "AllocCommandBuffers"))
-        return (void*) vkAllocCommandBuffers;
+    if (!strcmp(name, "AllocateCommandBuffers"))
+        return (void*) vkAllocateCommandBuffers;
     if (!strcmp(name, "FreeCommandBuffers"))
         return (void*) vkFreeCommandBuffers;
     if (!strcmp(name, "BeginCommandBuffer"))
@@ -356,8 +356,8 @@
         return (void*) vkDestroyDevice;
     if (!strcmp(name, "GetDeviceQueue"))
         return (void*) vkGetDeviceQueue;
-    if (!strcmp(name, "AllocCommandBuffers"))
-        return (void*) vkAllocCommandBuffers;
+    if (!strcmp(name, "AllocateCommandBuffers"))
+        return (void*) vkAllocateCommandBuffers;
 
     return NULL;
 }
diff --git a/loader/loader.c b/loader/loader.c
index 53fdbf3..c1ae293 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -111,63 +111,63 @@
 void* loader_heap_alloc(
     const struct loader_instance     *instance,
     size_t                            size,
-    VkSystemAllocScope                alloc_scope)
+    VkSystemAllocationScope                alloc_scope)
 {
-    if (instance && instance->alloc_callbacks.pfnAlloc) {
+    if (instance && instance->alloc_callbacks.pfnAllocation) {
         /* TODO: What should default alignment be? 1, 4, 8, other? */
-        return instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_scope);
+        return instance->alloc_callbacks.pfnAllocation(instance->alloc_callbacks.pUserData, size, 4, alloc_scope);
     }
     return malloc(size);
 }
 
 void loader_heap_free(
     const struct loader_instance   *instance,
-    void                           *pMem)
+    void                           *pMemory)
 {
-    if (pMem == NULL) return;
+    if (pMemory == NULL) return;
     if (instance && instance->alloc_callbacks.pfnFree) {
-        instance->alloc_callbacks.pfnFree(instance->alloc_callbacks.pUserData, pMem);
+        instance->alloc_callbacks.pfnFree(instance->alloc_callbacks.pUserData, pMemory);
         return;
     }
-    free(pMem);
+    free(pMemory);
 }
 
 void* loader_heap_realloc(
     const struct loader_instance *instance,
-    void                       *pMem,
+    void                       *pMemory,
     size_t                      orig_size,
     size_t                      size,
-    VkSystemAllocScope          alloc_scope)
+    VkSystemAllocationScope          alloc_scope)
 {
-    if (pMem == NULL  || orig_size == 0)
+    if (pMemory == NULL  || orig_size == 0)
         return loader_heap_alloc(instance, size, alloc_scope);
     if (size == 0) {
-        loader_heap_free(instance, pMem);
+        loader_heap_free(instance, pMemory);
         return NULL;
     }
-    if (instance && instance->alloc_callbacks.pfnAlloc) {
+    if (instance && instance->alloc_callbacks.pfnAllocation) {
         if (size <= orig_size) {
-            memset(((uint8_t *)pMem) + size,  0, orig_size - size);
-            return pMem;
+            memset(((uint8_t *)pMemory) + size,  0, orig_size - size);
+            return pMemory;
         }
-        void *new_ptr = instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_scope);
+        void *new_ptr = instance->alloc_callbacks.pfnAllocation(instance->alloc_callbacks.pUserData, size, 4, alloc_scope);
         if (!new_ptr)
             return NULL;
-        memcpy(new_ptr, pMem, orig_size);
-        instance->alloc_callbacks.pfnFree(instance->alloc_callbacks.pUserData, pMem);
+        memcpy(new_ptr, pMemory, orig_size);
+        instance->alloc_callbacks.pfnFree(instance->alloc_callbacks.pUserData, pMemory);
 	return new_ptr;
     }
-    return realloc(pMem, size);
+    return realloc(pMemory, size);
 }
 
 void *loader_tls_heap_alloc(size_t size)
 {
-    return loader_heap_alloc(tls_instance, size, VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
+    return loader_heap_alloc(tls_instance, size, VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION);
 }
 
-void loader_tls_heap_free(void *pMem)
+void loader_tls_heap_free(void *pMemory)
 {
-    loader_heap_free(tls_instance, pMem);
+    loader_heap_free(tls_instance, pMemory);
 }
 
 static void loader_log(VkFlags msg_type, int32_t msg_code,
@@ -247,11 +247,11 @@
         while ((rtn_value = RegEnumValue(key, idx++, name, &name_size, NULL, NULL, (LPBYTE) &value, &value_size)) == ERROR_SUCCESS) {
             if (value_size == sizeof(value) && value == 0) {
                 if (out == NULL) {
-                    out = loader_heap_alloc(inst, total_size, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                    out = loader_heap_alloc(inst, total_size, VK_SYSTEM_ALLOCATION_TYPE_INTERNAL);
                     out[0] = '\0';
                 }
                 else if (strlen(out) + name_size + 1 > total_size) {
-                    out = loader_heap_realloc(inst, out, total_size, total_size * 2, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                    out = loader_heap_realloc(inst, out, total_size, total_size * 2, VK_SYSTEM_ALLOCATION_TYPE_INTERNAL);
                     total_size *= 2;
                 }
                 if (out == NULL) {
@@ -363,7 +363,7 @@
 
 bool compare_vk_extension_properties(const VkExtensionProperties *op1, const VkExtensionProperties *op2)
 {
-    return strcmp(op1->extName, op2->extName) == 0 ? true : false;
+    return strcmp(op1->extensionName, op2->extensionName) == 0 ? true : false;
 }
 
 /**
@@ -429,7 +429,7 @@
     if (layer_list->capacity == 0) {
         layer_list->list = loader_heap_alloc(inst,
                                   sizeof(struct loader_layer_properties) * 64,
-                                  VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                  VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (layer_list->list == NULL) {
             loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't add any layer properties to list");
             return NULL;
@@ -444,7 +444,7 @@
         layer_list->list = loader_heap_realloc(inst, layer_list->list,
                                             layer_list->capacity,
                                             layer_list->capacity * 2,
-                                            VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (layer_list->list == NULL) {
             loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
                             "realloc failed for layer list");
@@ -524,7 +524,7 @@
                  VK_PATCH(ext_props[i].specVersion));
         loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
                    "Global Extension: %s (%s) version %s",
-                   ext_props[i].extName, lib_name, spec_version);
+                   ext_props[i].extensionName, lib_name, spec_version);
         loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
     }
 
@@ -561,7 +561,7 @@
                          VK_PATCH(ext_props[i].specVersion));
                 loader_log(VK_DBG_REPORT_DEBUG_BIT, 0,
                            "PhysicalDevice Extension: %s (%s) version %s",
-                           ext_props[i].extName, lib_name, spec_version);
+                           ext_props[i].extensionName, lib_name, spec_version);
                 loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
             }
         } else {
@@ -575,7 +575,7 @@
                                  struct loader_extension_list *ext_info)
 {
     ext_info->capacity = 32 * sizeof(VkExtensionProperties);
-    ext_info->list = loader_heap_alloc(inst, ext_info->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+    ext_info->list = loader_heap_alloc(inst, ext_info->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (ext_info->list == NULL) {
         return false;
     }
@@ -629,7 +629,7 @@
                                                  ext_list->list,
                                                  ext_list->capacity,
                                                  ext_list->capacity * 2,
-                                                 VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                                 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
             // double capacity
             ext_list->capacity *= 2;
         }
@@ -676,7 +676,7 @@
                                    struct loader_layer_list *list)
 {
     list->capacity = 32 * sizeof(struct loader_layer_properties);
-    list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+    list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (list->list == NULL) {
         return false;
     }
@@ -700,7 +700,7 @@
                                            struct loader_layer_library_list *list)
 {
     list->capacity = 32 * sizeof(struct loader_lib_info);
-    list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+    list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (list->list == NULL) {
         return false;
     }
@@ -755,7 +755,7 @@
                                              list->list,
                                              list->capacity,
                                              list->capacity * 2,
-                                             VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                             VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
             // double capacity
             list->capacity *= 2;
         }
@@ -833,7 +833,7 @@
                                              list->list,
                                              list->capacity,
                                              list->capacity * 2,
-                                             VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                             VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
             // double capacity
             list->capacity *= 2;
         }
@@ -877,7 +877,7 @@
         const struct loader_extension_list *list)
 {
     for (uint32_t i = 0; i < list->count; i++) {
-        if (strcmp(name, list->list[i].extName) == 0)
+        if (strcmp(name, list->list[i].extensionName) == 0)
             return &list->list[i];
     }
     return NULL;
@@ -958,7 +958,7 @@
 {
     struct loader_device *new_dev;
 
-    new_dev = loader_heap_alloc(inst, sizeof(struct loader_device), VK_SYSTEM_ALLOC_SCOPE_DEVICE);
+    new_dev = loader_heap_alloc(inst, sizeof(struct loader_device), VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
     if (!new_dev) {
         loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc struct laoder-device");
         return NULL;
@@ -1017,7 +1017,7 @@
 {
     struct loader_icd *icd;
 
-    icd = loader_heap_alloc(inst, sizeof(*icd), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+    icd = loader_heap_alloc(inst, sizeof(*icd), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (!icd)
         return NULL;
 
@@ -1068,7 +1068,7 @@
 {
     loader_scanned_icd_clear(inst, icd_libs);
     icd_libs->capacity = 8 * sizeof(struct loader_scanned_icds);
-    icd_libs->list = loader_heap_alloc(inst, icd_libs->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+    icd_libs->list = loader_heap_alloc(inst, icd_libs->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
 
 }
 
@@ -1113,7 +1113,7 @@
                                                  icd_libs->list,
                                                  icd_libs->capacity,
                                                  icd_libs->capacity * 2,
-                                                 VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                                 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
             // double capacity
             icd_libs->capacity *= 2;
     }
@@ -1126,7 +1126,7 @@
 
     new_node->lib_name = (char *) loader_heap_alloc(inst,
                                             strlen(filename) + 1,
-                                            VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (!new_node->lib_name) {
         loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Out of memory can't add icd");
         return;
@@ -1376,7 +1376,7 @@
                                         inst,
                                         sizeof(VkExtensionProperties) *
                                         src->instance_extension_list.count,
-                                        VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                        VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     dst->instance_extension_list.capacity = sizeof(VkExtensionProperties) *
                                         src->instance_extension_list.count;
     memcpy(dst->instance_extension_list.list, src->instance_extension_list.list,
@@ -1385,7 +1385,7 @@
                                         inst,
                                         sizeof(VkExtensionProperties) *
                                         src->device_extension_list.count,
-                                        VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                        VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     dst->device_extension_list.capacity = sizeof(VkExtensionProperties) *
                                         src->device_extension_list.count;
     memcpy(dst->device_extension_list.list, src->device_extension_list.list,
@@ -1532,7 +1532,7 @@
             loader_get_fullpath(library_path, DEFAULT_VK_LAYERS_PATH, MAX_STRING_SIZE, fullpath);
         }
         props->info.specVersion = loader_make_version(abi_versions);
-        props->info.implVersion = loader_make_version(implementation_version);
+        props->info.implementationVersion = loader_make_version(implementation_version);
         strncpy((char *) props->info.description, description, sizeof (props->info.description));
         props->info.description[sizeof (props->info.description) - 1] = '\0';
         if (is_implicit) {
@@ -1583,8 +1583,8 @@
                 ext_item = cJSON_GetArrayItem(instance_extensions, i);
                 GET_JSON_ITEM(ext_item, name)
                 GET_JSON_ITEM(ext_item, version)
-                strncpy(ext_prop.extName, name, sizeof (ext_prop.extName));
-                ext_prop.extName[sizeof (ext_prop.extName) - 1] = '\0';
+                strncpy(ext_prop.extensionName, name, sizeof (ext_prop.extensionName));
+                ext_prop.extensionName[sizeof (ext_prop.extensionName) - 1] = '\0';
                 ext_prop.specVersion = loader_make_version(version);
                 loader_add_to_ext_list(inst, &props->instance_extension_list, 1, &ext_prop);
             }
@@ -1596,8 +1596,8 @@
                 ext_item = cJSON_GetArrayItem(device_extensions, i);
                 GET_JSON_ITEM(ext_item, name);
                 GET_JSON_ITEM(ext_item, version);
-                strncpy(ext_prop.extName, name, sizeof (ext_prop.extName));
-                ext_prop.extName[sizeof (ext_prop.extName) - 1] = '\0';
+                strncpy(ext_prop.extensionName, name, sizeof (ext_prop.extensionName));
+                ext_prop.extensionName[sizeof (ext_prop.extensionName) - 1] = '\0';
                 ext_prop.specVersion = loader_make_version(version);
                 loader_add_to_ext_list(inst, &props->device_extension_list, 1, &ext_prop);
             }
@@ -1759,14 +1759,14 @@
                     if (out_files->count == 0) {
                         out_files->filename_list = loader_heap_alloc(inst,
                                               alloced_count * sizeof(char *),
-                                              VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
+                                              VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION);
                     }
                     else if (out_files->count == alloced_count) {
                         out_files->filename_list = loader_heap_realloc(inst,
                                         out_files->filename_list,
                                         alloced_count * sizeof(char *),
                                         alloced_count * sizeof(char *) * 2,
-                                        VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
+                                        VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION);
                         alloced_count *= 2;
                     }
                     if (out_files->filename_list == NULL) {
@@ -1776,7 +1776,7 @@
                     out_files->filename_list[out_files->count] = loader_heap_alloc(
                                                 inst,
                                                 strlen(name) + 1,
-                                                VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
+                                                VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION);
                     if (out_files->filename_list[out_files->count] == NULL) {
                         loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files");
                         return;
@@ -2073,7 +2073,7 @@
                                             inst, loader.loaded_layer_lib_list,
                                             loader.loaded_layer_lib_capacity,
                                             new_alloc_size,
-                                            VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (!new_layer_lib_list) {
             loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "loader: realloc failed in loader_add_layer_lib");
             return NULL;
@@ -2135,7 +2135,7 @@
     /* Need to remove unused library from list */
     new_layer_lib_list = loader_heap_alloc(inst,
                                            loader.loaded_layer_lib_capacity,
-                                           VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                           VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (!new_layer_lib_list) {
         loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "loader: heap alloc failed loader_remove_layer_library");
         return;
@@ -2415,7 +2415,7 @@
 static VkResult VKAPI scratch_vkCreateDevice(
     VkPhysicalDevice          gpu,
     const VkDeviceCreateInfo *pCreateInfo,
-    const VkAllocCallbacks*   pAllocator,
+    const VkAllocationCallbacks*   pAllocator,
     VkDevice                 *pDevice)
 {
     return VK_SUCCESS;
@@ -2457,7 +2457,7 @@
 
     wrappedGpus = loader_heap_alloc(inst,
                     sizeof (VkBaseLayerObject) * dev->activated_layer_list.count,
-                    VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (!wrappedGpus) {
         loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc Gpu objects for layer");
         return 0;
@@ -2613,7 +2613,7 @@
 
 VkResult VKAPI loader_CreateInstance(
         const VkInstanceCreateInfo*     pCreateInfo,
-        const VkAllocCallbacks*         pAllocator,
+        const VkAllocationCallbacks*         pAllocator,
         VkInstance*                     pInstance)
 {
     struct loader_instance *ptr_instance = *(struct loader_instance **) pInstance;
@@ -2627,7 +2627,7 @@
     icd_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     icd_create_info.enabledLayerNameCount = 0;
     icd_create_info.ppEnabledLayerNames = NULL;
-    icd_create_info.pAppInfo = pCreateInfo->pAppInfo;
+    icd_create_info.pApplicationInfo = pCreateInfo->pApplicationInfo;
     icd_create_info.pNext = pCreateInfo->pNext;
 
     /*
@@ -2693,7 +2693,7 @@
 
 void VKAPI loader_DestroyInstance(
         VkInstance                                instance,
-        const VkAllocCallbacks*                   pAllocator)
+        const VkAllocationCallbacks*                   pAllocator)
 {
     struct loader_instance *ptr_instance = loader_instance(instance);
     struct loader_icd *icds = ptr_instance->icds;
@@ -2757,7 +2757,7 @@
         icd->gpus = (VkPhysicalDevice *) loader_heap_alloc(
                                                 ptr_instance,
                                                 n * sizeof(VkPhysicalDevice),
-                                                VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                                                VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
         if (!icd->gpus) {
             /* TODO: Add cleanup code here */
             return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -2930,7 +2930,7 @@
 VkResult VKAPI loader_CreateDevice(
         VkPhysicalDevice                        gpu,
         const VkDeviceCreateInfo*               pCreateInfo,
-        const VkAllocCallbacks*                 pAllocator,
+        const VkAllocationCallbacks*                 pAllocator,
         VkDevice*                               pDevice)
 {
     uint32_t gpu_index;
diff --git a/loader/loader.h b/loader/loader.h
index 96dd277..2e64e4b 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -181,7 +181,7 @@
     bool debug_report_enabled;
     VkLayerDbgFunctionNode *DbgFunctionHead;
 
-    VkAllocCallbacks alloc_callbacks;
+    VkAllocationCallbacks alloc_callbacks;
 
     bool wsi_swapchain_enabled;
 };
@@ -265,12 +265,12 @@
 /* instance layer chain termination entrypoint definitions */
 VkResult VKAPI loader_CreateInstance(
         const VkInstanceCreateInfo*             pCreateInfo,
-        const VkAllocCallbacks*                 pAllocator,
+        const VkAllocationCallbacks*                 pAllocator,
         VkInstance*                             pInstance);
 
 void VKAPI loader_DestroyInstance(
         VkInstance                              instance,
-        const VkAllocCallbacks*                 pAllocator);
+        const VkAllocationCallbacks*                 pAllocator);
 
 VkResult VKAPI loader_EnumeratePhysicalDevices(
         VkInstance                              instance,
@@ -328,7 +328,7 @@
 VkResult VKAPI loader_CreateDevice(
         VkPhysicalDevice                        gpu,
         const VkDeviceCreateInfo*               pCreateInfo,
-        const VkAllocCallbacks*                 pAllocator,
+        const VkAllocationCallbacks*                 pAllocator,
         VkDevice*                               pDevice);
 
 /* helper function definitions */
@@ -393,13 +393,13 @@
 void* loader_heap_alloc(
         const struct loader_instance *instance,
         size_t                       size,
-        VkSystemAllocScope           allocScope);
+        VkSystemAllocationScope           allocationScope);
 
 void loader_heap_free(
         const struct loader_instance *instance,
-        void                         *pMem);
+        void                         *pMemory);
 
 void *loader_tls_heap_alloc(size_t size);
 
-void loader_tls_heap_free(void *pMem);
+void loader_tls_heap_free(void *pMemory);
 #endif /* LOADER_H */
diff --git a/loader/table_ops.h b/loader/table_ops.h
index d4a167e..29bdc38 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -43,7 +43,7 @@
     table->QueueSubmit = (PFN_vkQueueSubmit) gpa(dev, "vkQueueSubmit");
     table->QueueWaitIdle = (PFN_vkQueueWaitIdle) gpa(dev, "vkQueueWaitIdle");
     table->DeviceWaitIdle = (PFN_vkDeviceWaitIdle) gpa(dev, "vkDeviceWaitIdle");
-    table->AllocMemory = (PFN_vkAllocMemory) gpa(dev, "vkAllocMemory");
+    table->AllocateMemory = (PFN_vkAllocateMemory) gpa(dev, "vkAllocateMemory");
     table->FreeMemory = (PFN_vkFreeMemory) gpa(dev, "vkFreeMemory");
     table->MapMemory = (PFN_vkMapMemory) gpa(dev, "vkMapMemory");
     table->UnmapMemory = (PFN_vkUnmapMemory) gpa(dev, "vkUnmapMemory");
@@ -100,7 +100,7 @@
     table->CreateDescriptorPool = (PFN_vkCreateDescriptorPool) gpa(dev, "vkCreateDescriptorPool");
     table->DestroyDescriptorPool = (PFN_vkDestroyDescriptorPool) gpa(dev, "vkDestroyDescriptorPool");
     table->ResetDescriptorPool = (PFN_vkResetDescriptorPool) gpa(dev, "vkResetDescriptorPool");
-    table->AllocDescriptorSets = (PFN_vkAllocDescriptorSets) gpa(dev, "vkAllocDescriptorSets");
+    table->AllocateDescriptorSets = (PFN_vkAllocateDescriptorSets) gpa(dev, "vkAllocateDescriptorSets");
     table->FreeDescriptorSets = (PFN_vkFreeDescriptorSets) gpa(dev, "vkFreeDescriptorSets");
     table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) gpa(dev, "vkUpdateDescriptorSets");
     table->CreateFramebuffer = (PFN_vkCreateFramebuffer) gpa(dev, "vkCreateFramebuffer");
@@ -111,7 +111,7 @@
     table->CreateCommandPool = (PFN_vkCreateCommandPool) gpa(dev, "vkCreateCommandPool");
     table->DestroyCommandPool = (PFN_vkDestroyCommandPool) gpa(dev, "vkDestroyCommandPool");
     table->ResetCommandPool = (PFN_vkResetCommandPool) gpa(dev, "vkResetCommandPool");
-    table->AllocCommandBuffers = (PFN_vkAllocCommandBuffers) gpa(dev, "vkAllocCommandBuffers");
+    table->AllocateCommandBuffers = (PFN_vkAllocateCommandBuffers) gpa(dev, "vkAllocateCommandBuffers");
     table->FreeCommandBuffers = (PFN_vkFreeCommandBuffers) gpa(dev, "vkFreeCommandBuffers");
     table->BeginCommandBuffer = (PFN_vkBeginCommandBuffer) gpa(dev, "vkBeginCommandBuffer");
     table->EndCommandBuffer = (PFN_vkEndCommandBuffer) gpa(dev, "vkEndCommandBuffer");
@@ -195,8 +195,8 @@
         return (void *) table->QueueWaitIdle;
     if (!strcmp(name, "DeviceWaitIdle"))
         return (void *) table->DeviceWaitIdle;
-    if (!strcmp(name, "AllocMemory"))
-        return (void *) table->AllocMemory;
+    if (!strcmp(name, "AllocateMemory"))
+        return (void *) table->AllocateMemory;
     if (!strcmp(name, "FreeMemory"))
         return (void *) table->FreeMemory;
     if (!strcmp(name, "MapMemory"))
@@ -309,8 +309,8 @@
         return (void *) table->DestroyDescriptorPool;
     if (!strcmp(name, "ResetDescriptorPool"))
         return (void *) table->ResetDescriptorPool;
-    if (!strcmp(name, "AllocDescriptorSets"))
-        return (void *) table->AllocDescriptorSets;
+    if (!strcmp(name, "AllocateDescriptorSets"))
+        return (void *) table->AllocateDescriptorSets;
     if (!strcmp(name, "FreeDescriptorSets"))
         return (void *) table->FreeDescriptorSets;
     if (!strcmp(name, "UpdateDescriptorSets"))
@@ -331,8 +331,8 @@
         return (void *) table->DestroyCommandPool;
     if (!strcmp(name, "ResetCommandPool"))
         return (void *) table->ResetCommandPool;
-    if (!strcmp(name, "AllocCommandBuffers"))
-        return (void *) table->AllocCommandBuffers;
+    if (!strcmp(name, "AllocateCommandBuffers"))
+        return (void *) table->AllocateCommandBuffers;
     if (!strcmp(name, "FreeCommandBuffers"))
         return (void *) table->FreeCommandBuffers;
     if (!strcmp(name, "BeginCommandBuffer"))
diff --git a/loader/trampoline.c b/loader/trampoline.c
index 2a240f1..fb863f6 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -34,7 +34,7 @@
 /* Trampoline entrypoints */
 LOADER_EXPORT VkResult VKAPI vkCreateInstance(
         const VkInstanceCreateInfo* pCreateInfo,
-        const VkAllocCallbacks* pAllocator,
+        const VkAllocationCallbacks* pAllocator,
         VkInstance* pInstance)
 {
     struct loader_instance *ptr_instance = NULL;
@@ -43,11 +43,11 @@
     loader_platform_thread_once(&once_init, loader_initialize);
 
     if (pAllocator) {
-        ptr_instance = (struct loader_instance *) pAllocator->pfnAlloc(
+        ptr_instance = (struct loader_instance *) pAllocator->pfnAllocation(
                            pAllocator->pUserData,
                            sizeof(struct loader_instance),
                            sizeof(VkInstance),
-                           VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                           VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     } else {
         ptr_instance = (struct loader_instance *) malloc(sizeof(struct loader_instance));
     }
@@ -111,7 +111,7 @@
     ptr_instance->disp = loader_heap_alloc(
                              ptr_instance,
                              sizeof(VkLayerInstanceDispatchTable),
-                             VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+                             VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
     if (ptr_instance->disp == NULL) {
         loader_delete_layer_properties(ptr_instance,
                                        &ptr_instance->device_layer_list);
@@ -172,7 +172,7 @@
 
 LOADER_EXPORT void VKAPI vkDestroyInstance(
                                             VkInstance instance,
-                                            const VkAllocCallbacks* pAllocator)
+                                            const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerInstanceDispatchTable *disp;
     struct loader_instance *ptr_instance = NULL;
@@ -273,7 +273,7 @@
 LOADER_EXPORT VkResult VKAPI vkCreateDevice(
         VkPhysicalDevice gpu,
         const VkDeviceCreateInfo* pCreateInfo,
-        const VkAllocCallbacks* pAllocator,
+        const VkAllocationCallbacks* pAllocator,
         VkDevice* pDevice)
 {
     VkResult res;
@@ -286,7 +286,7 @@
     return res;
 }
 
-LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
     struct loader_device *dev;
@@ -366,16 +366,16 @@
     return disp->DeviceWaitIdle(device);
 }
 
-LOADER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem)
+LOADER_EXPORT VkResult VKAPI vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->AllocMemory(device, pAllocInfo, pAllocator, pMem);
+    return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
 }
 
-LOADER_EXPORT void VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -402,22 +402,22 @@
     disp->UnmapMemory(device, mem);
 }
 
-LOADER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges)
+LOADER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
+    return disp->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
 }
 
-LOADER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges)
+LOADER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
+    return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
 }
 
 LOADER_EXPORT void VKAPI vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
@@ -492,7 +492,7 @@
     return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence)
+LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
 {
     const VkLayerDispatchTable *disp;
 
@@ -501,7 +501,7 @@
     return disp->CreateFence(device, pCreateInfo, pAllocator, pFence);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -537,7 +537,7 @@
     return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore)
+LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
 {
     const VkLayerDispatchTable *disp;
 
@@ -546,7 +546,7 @@
     return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
 }
 
-LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -555,7 +555,7 @@
     disp->DestroySemaphore(device, semaphore, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent)
+LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
 {
     const VkLayerDispatchTable *disp;
 
@@ -564,7 +564,7 @@
     return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -600,7 +600,7 @@
     return disp->ResetEvent(device, event);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool)
+LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
 {
     const VkLayerDispatchTable *disp;
 
@@ -609,7 +609,7 @@
     return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -627,7 +627,7 @@
     return disp->GetQueryPoolResults(device, queryPool, startQuery, queryCount, dataSize, pData, stride, flags);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer)
+LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
 {
     const VkLayerDispatchTable *disp;
 
@@ -636,7 +636,7 @@
     return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -645,7 +645,7 @@
     disp->DestroyBuffer(device, buffer, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView)
+LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
 {
     const VkLayerDispatchTable *disp;
 
@@ -654,7 +654,7 @@
     return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -663,7 +663,7 @@
     disp->DestroyBufferView(device, bufferView, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage)
+LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
 {
     const VkLayerDispatchTable *disp;
 
@@ -672,7 +672,7 @@
     return disp->CreateImage(device, pCreateInfo, pAllocator, pImage);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -690,7 +690,7 @@
     disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView)
+LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
 {
     const VkLayerDispatchTable *disp;
 
@@ -699,7 +699,7 @@
     return disp->CreateImageView(device, pCreateInfo, pAllocator, pView);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -708,7 +708,7 @@
     disp->DestroyImageView(device, imageView, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShader)
+LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShader)
 {
     const VkLayerDispatchTable *disp;
 
@@ -717,7 +717,7 @@
     return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -726,7 +726,7 @@
     disp->DestroyShaderModule(device, shaderModule, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader)
+LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader)
 {
     const VkLayerDispatchTable *disp;
 
@@ -735,7 +735,7 @@
     return disp->CreateShader(device, pCreateInfo, pAllocator, pShader);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -744,7 +744,7 @@
     disp->DestroyShader(device, shader, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
 {
     const VkLayerDispatchTable *disp;
 
@@ -753,7 +753,7 @@
     return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -771,16 +771,16 @@
     return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
 }
 
-LOADER_EXPORT VkResult VKAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+LOADER_EXPORT VkResult VKAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
+    return disp->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines)
+LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
 {
     const VkLayerDispatchTable *disp;
 
@@ -789,7 +789,7 @@
     return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines)
+LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
 {
     const VkLayerDispatchTable *disp;
 
@@ -798,7 +798,7 @@
     return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -807,7 +807,7 @@
     disp->DestroyPipeline(device, pipeline, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
 {
     const VkLayerDispatchTable *disp;
 
@@ -816,7 +816,7 @@
     return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -825,7 +825,7 @@
     disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler)
+LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
 {
     const VkLayerDispatchTable *disp;
 
@@ -834,7 +834,7 @@
     return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
 }
 
-LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -844,7 +844,7 @@
 }
 
 
-LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
 {
     const VkLayerDispatchTable *disp;
 
@@ -853,7 +853,7 @@
     return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -862,7 +862,7 @@
     disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
 {
     const VkLayerDispatchTable *disp;
 
@@ -871,7 +871,7 @@
     return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -890,13 +890,13 @@
     return disp->ResetDescriptorPool(device, descriptorPool, flags);
 }
 
-LOADER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets)
+LOADER_EXPORT VkResult VKAPI vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
+    return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
 }
 
 LOADER_EXPORT VkResult VKAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
@@ -917,7 +917,7 @@
     disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
 {
     const VkLayerDispatchTable *disp;
 
@@ -926,7 +926,7 @@
     return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -935,7 +935,7 @@
     disp->DestroyFramebuffer(device, framebuffer, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass)
+LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
 {
     const VkLayerDispatchTable *disp;
 
@@ -944,7 +944,7 @@
     return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
@@ -962,48 +962,48 @@
     disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool)
+LOADER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
+    return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator)
+LOADER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyCommandPool(device, cmdPool, pAllocator);
+    disp->DestroyCommandPool(device, commandPool, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags)
+LOADER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->ResetCommandPool(device, cmdPool, flags);
+    return disp->ResetCommandPool(device, commandPool, flags);
 }
 
-LOADER_EXPORT VkResult VKAPI vkAllocCommandBuffers(
+LOADER_EXPORT VkResult VKAPI vkAllocateCommandBuffers(
         VkDevice device,
-        const VkCmdBufferAllocInfo* pAllocInfo,
-        VkCmdBuffer* pCmdBuffers)
+        const VkCommandBufferAllocateInfo* pAllocateInfo,
+        VkCommandBuffer* pCommandBuffers)
 {
     const VkLayerDispatchTable *disp;
     VkResult res;
 
     disp = loader_get_dispatch(device);
 
-    res = disp->AllocCommandBuffers(device, pAllocInfo, pCmdBuffers);
+    res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
     if (res == VK_SUCCESS) {
-        for (uint32_t i =0; i < pAllocInfo->bufferCount; i++) {
-            if (pCmdBuffers[i]) {
-                loader_init_dispatch(pCmdBuffers[i], disp);
+        for (uint32_t i =0; i < pAllocateInfo->bufferCount; i++) {
+            if (pCommandBuffers[i]) {
+                loader_init_dispatch(pCommandBuffers[i], disp);
             }
         }
     }
@@ -1013,436 +1013,436 @@
 
 LOADER_EXPORT void VKAPI vkFreeCommandBuffers(
         VkDevice                                device,
-        VkCmdPool                               cmdPool,
+        VkCommandPool                               commandPool,
         uint32_t                                commandBufferCount,
-        const VkCmdBuffer*                      pCommandBuffers)
+        const VkCommandBuffer*                      pCommandBuffers)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->FreeCommandBuffers(device, cmdPool, commandBufferCount, pCommandBuffers);
+    disp->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
 }
 
-LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
+LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    return disp->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+    return disp->BeginCommandBuffer(commandBuffer, pBeginInfo);
 }
 
-LOADER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
+LOADER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCommandBuffer commandBuffer)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    return disp->EndCommandBuffer(cmdBuffer);
+    return disp->EndCommandBuffer(commandBuffer);
 }
 
-LOADER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags)
+LOADER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    return disp->ResetCommandBuffer(cmdBuffer, flags);
+    return disp->ResetCommandBuffer(commandBuffer, flags);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+LOADER_EXPORT void VKAPI vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+    disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports)
+LOADER_EXPORT void VKAPI vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetViewport(cmdBuffer, viewportCount, pViewports);
+    disp->CmdSetViewport(commandBuffer, viewportCount, pViewports);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
+LOADER_EXPORT void VKAPI vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetScissor(cmdBuffer, scissorCount, pScissors);
+    disp->CmdSetScissor(commandBuffer, scissorCount, pScissors);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth)
+LOADER_EXPORT void VKAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetLineWidth(cmdBuffer, lineWidth);
+    disp->CmdSetLineWidth(commandBuffer, lineWidth);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+LOADER_EXPORT void VKAPI vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetDepthBias(cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+    disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConstants[4])
+LOADER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetBlendConstants(cmdBuffer, blendConstants);
+    disp->CmdSetBlendConstants(commandBuffer, blendConstants);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds)
+LOADER_EXPORT void VKAPI vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds);
+    disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask)
+LOADER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask);
+    disp->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask)
+LOADER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask);
+    disp->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference)
+LOADER_EXPORT void VKAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
+    disp->CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+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)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+    disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+LOADER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+    disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
+LOADER_EXPORT void VKAPI vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+    disp->CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets);
 }
 
-LOADER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+LOADER_EXPORT void VKAPI vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdDraw(cmdBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+    disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
 }
 
-LOADER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+LOADER_EXPORT void VKAPI vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdDrawIndexed(cmdBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+    disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 }
 
-LOADER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+LOADER_EXPORT void VKAPI vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdDrawIndirect(cmdBuffer, buffer, offset, drawCount, stride);
+    disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
 }
 
-LOADER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+LOADER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, drawCount, stride);
+    disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
 }
 
-LOADER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
+LOADER_EXPORT void VKAPI vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdDispatch(cmdBuffer, x, y, z);
+    disp->CmdDispatch(commandBuffer, x, y, z);
 }
 
-LOADER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset)
+LOADER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdDispatchIndirect(cmdBuffer, buffer, offset);
+    disp->CmdDispatchIndirect(commandBuffer, buffer, offset);
 }
 
-LOADER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+LOADER_EXPORT void VKAPI vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+    disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
 }
 
-LOADER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
+LOADER_EXPORT void VKAPI vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+    disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
+LOADER_EXPORT void VKAPI vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+    disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
 }
 
-LOADER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+LOADER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+    disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-LOADER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+LOADER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+    disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
 }
 
-LOADER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData)
+LOADER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+    disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 }
 
-LOADER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data)
+LOADER_EXPORT void VKAPI vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+    disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 }
 
-LOADER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+LOADER_EXPORT void VKAPI vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+    disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 }
 
-LOADER_EXPORT void VKAPI vkCmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+LOADER_EXPORT void VKAPI vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+    disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 }
 
-LOADER_EXPORT void VKAPI vkCmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
+LOADER_EXPORT void VKAPI vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdClearAttachments(cmdBuffer, attachmentCount, pAttachments, rectCount, pRects);
+    disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
 }
 
-LOADER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
+LOADER_EXPORT void VKAPI vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+    disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-LOADER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+LOADER_EXPORT void VKAPI vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdSetEvent(cmdBuffer, event, stageMask);
+    disp->CmdSetEvent(commandBuffer, event, stageMask);
 }
 
-LOADER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+LOADER_EXPORT void VKAPI vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdResetEvent(cmdBuffer, event, stageMask);
+    disp->CmdResetEvent(commandBuffer, event, stageMask);
 }
 
-LOADER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers)
+LOADER_EXPORT void VKAPI vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
+    disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers);
 }
 
-LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers)
+LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, dependencyFlags, memBarrierCount, ppMemBarriers);
+    disp->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
+LOADER_EXPORT void VKAPI vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+    disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
 }
 
-LOADER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot)
+LOADER_EXPORT void VKAPI vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdEndQuery(cmdBuffer, queryPool, slot);
+    disp->CmdEndQuery(commandBuffer, queryPool, slot);
 }
 
-LOADER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
+LOADER_EXPORT void VKAPI vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+    disp->CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
 }
 
-LOADER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot)
+LOADER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
+    disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
 }
 
-LOADER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkFlags flags)
+LOADER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkFlags flags)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, stride, flags);
+    disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, stride, flags);
 }
 
-LOADER_EXPORT void VKAPI vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values)
+LOADER_EXPORT void VKAPI vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdPushConstants(cmdBuffer, layout, stageFlags, offset, size, values);
+    disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, values);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents)
+LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
+    disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
 }
 
-LOADER_EXPORT void VKAPI vkCmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents)
+LOADER_EXPORT void VKAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkRenderPassContents contents)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdNextSubpass(cmdBuffer, contents);
+    disp->CmdNextSubpass(commandBuffer, contents);
 }
 
-LOADER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer)
+LOADER_EXPORT void VKAPI vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdEndRenderPass(cmdBuffer);
+    disp->CmdEndRenderPass(commandBuffer);
 }
 
-LOADER_EXPORT void VKAPI vkCmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers)
+LOADER_EXPORT void VKAPI vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(cmdBuffer);
+    disp = loader_get_dispatch(commandBuffer);
 
-    disp->CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
+    disp->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
 }
diff --git a/loader/vk-loader-generate.py b/loader/vk-loader-generate.py
index 6439703..d8d06b4 100755
--- a/loader/vk-loader-generate.py
+++ b/loader/vk-loader-generate.py
@@ -49,7 +49,7 @@
         # Dont be cute trying to use a general rule to programmatically populate this list
         # it just obsfucates what is going on!
         wsi_creates_dispatchable_object = ["CreateSwapchainKHR"]
-        creates_dispatchable_object = ["CreateDevice", "GetDeviceQueue", "AllocCommandBuffers"] + wsi_creates_dispatchable_object
+        creates_dispatchable_object = ["CreateDevice", "GetDeviceQueue", "AllocateCommandBuffers"] + wsi_creates_dispatchable_object
         if name in creates_dispatchable_object:
             return True
         else:
diff --git a/loader/wsi_swapchain.c b/loader/wsi_swapchain.c
index a20549a..e362139 100644
--- a/loader/wsi_swapchain.c
+++ b/loader/wsi_swapchain.c
@@ -36,7 +36,7 @@
 #include "wsi_swapchain.h"
 
 static const VkExtensionProperties wsi_swapchain_extension_info = {
-        .extName = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME,
+        .extensionName = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME,
         .specVersion = VK_EXT_KHR_SWAPCHAIN_REVISION,
 };
 
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index d7844f5..ea5e71f 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -143,8 +143,8 @@
     VkDeviceSize offset = 0;
     for (std::vector<VkImageSubresourceRange>::const_iterator it = ranges.begin();
          it != ranges.end(); it++) {
-        for (uint32_t lv = 0; lv < it->numLevels; lv++) {
-            for (uint32_t layer = 0; layer < it->numLayers; layer++) {
+        for (uint32_t lv = 0; lv < it->levelCount; lv++) {
+            for (uint32_t layer = 0; layer < it->layerCount; layer++) {
                 VkBufferImageCopy region = {};
                 region.bufferOffset = offset;
                 region.imageSubresource = Image::subresource(*it, lv, layer, 1);
@@ -305,7 +305,7 @@
         VkFormat format;
         size_t size;
         uint32_t channel_count;
-    } format_table[VK_FORMAT_NUM] = {
+    } format_table[VK_FORMAT_RANGE_SIZE] = {
         { VK_FORMAT_UNDEFINED,             0,  0 },
         { VK_FORMAT_R4G4_UNORM,            1,  2 },
         { VK_FORMAT_R4G4_USCALED,          1,  2 },
@@ -484,7 +484,7 @@
     };
     if (format_table_unverified)
     {
-        for (unsigned int i = 0; i < VK_FORMAT_NUM; i++)
+        for (unsigned int i = 0; i < VK_FORMAT_RANGE_SIZE; i++)
         {
             assert(format_table[i].format == i);
         }
@@ -518,8 +518,8 @@
     VkCmdBlitTest() :
         dev_(environment->default_device()),
         queue_(*dev_.graphics_queues()[0]),
-        pool_(dev_, vk_testing::CmdPool::create_info(dev_.graphics_queue_node_index_)),
-        cmd_(dev_, vk_testing::CmdBuffer::create_info(pool_.handle()))
+        pool_(dev_, vk_testing::CommandPool::create_info(dev_.graphics_queue_node_index_)),
+        cmd_(dev_, vk_testing::CommandBuffer::create_info(pool_.handle()))
     {
         // make sure every test uses a different pattern
         vk_testing::ImageChecker::hash_salt_generate();
@@ -535,8 +535,8 @@
 
     vk_testing::Device &dev_;
     vk_testing::Queue &queue_;
-    vk_testing::CmdPool pool_;
-    vk_testing::CmdBuffer cmd_;
+    vk_testing::CommandPool pool_;
+    vk_testing::CommandBuffer cmd_;
 
     /* TODO: We should be able to remove these now */
     std::vector<VkDeviceMemory> mem_refs_;
@@ -739,9 +739,9 @@
         const VkBufferCopy &r = regions[i];
 
         for (int j = 0; j < r.size; j++) {
-            EXPECT_EQ(r.srcOffset + j, data[r.destOffset + j]) <<
+            EXPECT_EQ(r.srcOffset + j, data[r.dstOffset + j]) <<
                 "Region is: " << i << "\n" <<
-                "Offset is: " << r.destOffset + j;
+                "Offset is: " << r.dstOffset + j;
         }
     }
     dst.memory().unmap();
@@ -870,7 +870,7 @@
         // copy in and tile
         cmd_.begin();
         vkCmdCopyBufferToImage(cmd_.handle(), in_buf.handle(),
-                img.handle(), VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
+                img.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
 
@@ -893,7 +893,7 @@
         // copy out and linearize
         cmd_.begin();
         vkCmdCopyImageToBuffer(cmd_.handle(),
-                img.handle(), VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
+                img.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                 out_buf.handle(),
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
@@ -933,7 +933,7 @@
         cmd_.begin();
         vkCmdCopyBufferToImage(cmd_.handle(),
                 buf.handle(),
-                img.handle(), VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
+                img.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
 
@@ -972,8 +972,8 @@
         img_info.extent.width = 64;
         img_info.extent.height = 64;
         img_info.tiling = it->tiling;
-        img_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT |
-                         VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT;
+        img_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
 
         test_copy_memory_to_image(img_info);
     }
@@ -1003,7 +1003,7 @@
 
         cmd_.begin();
         vkCmdCopyImageToBuffer(cmd_.handle(),
-                img.handle(), VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
+                img.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                 buf.handle(),
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
@@ -1043,8 +1043,8 @@
         img_info.extent.width = 64;
         img_info.extent.height = 64;
         img_info.tiling = it->tiling;
-        img_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT |
-                         VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT; // Going to fill it before copy
+        img_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+                         VK_IMAGE_USAGE_TRANSFER_DST_BIT; // Going to fill it before copy
 
         test_copy_image_to_memory(img_info);
     }
@@ -1075,8 +1075,8 @@
             src_regions.push_back(src_region);
 
             dst_region.bufferOffset = src_offset;
-            dst_region.imageSubresource = it->destSubresource;
-            dst_region.imageOffset = it->destOffset;
+            dst_region.imageSubresource = it->dstSubresource;
+            dst_region.imageOffset = it->dstOffset;
             dst_region.imageExtent = it->extent;
             dst_regions.push_back(dst_region);
 
@@ -1103,8 +1103,8 @@
 
         cmd_.begin();
         vkCmdCopyImage(cmd_.handle(),
-                        src.handle(), VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
-                        dst.handle(), VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
+                        src.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                        dst.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                         copies.size(), &copies[0]);
         cmd_.end();
 
@@ -1131,11 +1131,11 @@
         img_info.extent.width = 64;
         img_info.extent.height = 64;
         img_info.tiling = it->tiling;
-        img_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT | VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT;
+        img_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
         VkImageCopy copy = {};
         copy.srcSubresource = vk_testing::Image::subresource(VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1);
-        copy.destSubresource = copy.srcSubresource;
+        copy.dstSubresource = copy.srcSubresource;
         copy.extent = img_info.extent;
 
         test_copy_image(img_info, img_info, std::vector<VkImageCopy>(&copy, &copy + 1));
@@ -1225,7 +1225,7 @@
             p_to_clear.push_back(&to_clear.back());
             to_xfer.push_back(img.image_memory_barrier(all_cache_outputs, all_cache_inputs,
                     VK_IMAGE_LAYOUT_GENERAL,
-                    VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, *it));
+                    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *it));
             p_to_xfer.push_back(&to_xfer.back());
         }
 
@@ -1291,7 +1291,7 @@
         img_info.extent.height = 64;
         img_info.tiling = it->tiling;
         img_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
-                         VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT; // Going to check contents
+                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT; // Going to check contents
 
         const VkImageSubresourceRange range =
             vk_testing::Image::subresource_range(img_info, VK_IMAGE_ASPECT_COLOR_BIT);
@@ -1405,7 +1405,7 @@
 
             to_xfer.push_back(img.image_memory_barrier(all_cache_outputs, all_cache_inputs,
                     VK_IMAGE_LAYOUT_GENERAL,
-                    VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, *it));
+                    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *it));
         }
         for (std::vector<VkImageSubresourceRange>::const_iterator it = ranges.begin();
              it != ranges.end(); it++) {
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index 34afc93..de642f6 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -88,15 +88,15 @@
 
         this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
         this->app_info.pNext = NULL;
-        this->app_info.pAppName = "base";
-        this->app_info.appVersion = 1;
+        this->app_info.pApplicationName = "base";
+        this->app_info.applicationVersion = 1;
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
         this->app_info.apiVersion = VK_API_VERSION;
         VkInstanceCreateInfo inst_info = {};
         inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
         inst_info.pNext = NULL;
-        inst_info.pAppInfo = &app_info;
+        inst_info.pApplicationInfo = &app_info;
         inst_info.enabledLayerNameCount = 0;
         inst_info.ppEnabledLayerNames = NULL;
         inst_info.enabledExtensionNameCount = 0;
@@ -196,8 +196,8 @@
     //        VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT                       = 0x00000008,
     //typedef enum VkImageUsageFlags_
     //{
-    //    VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT                      = 0x00000001,   // Can be used as a source of transfer operations
-    //    VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT                 = 0x00000002,   // Can be used as a destination of transfer operations
+    //    VK_IMAGE_USAGE_TRANSFER_SRC_BIT                      = 0x00000001,   // Can be used as a source of transfer operations
+    //    VK_IMAGE_USAGE_TRANSFER_DST_BIT                 = 0x00000002,   // Can be used as a destination of transfer operations
     //    VK_IMAGE_USAGE_SAMPLED_BIT                              = 0x00000004,   // Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
     //    VK_IMAGE_USAGE_STORAGE_BIT                              = 0x00000008,   // Can be used as storage image (STORAGE_IMAGE descriptor type)
     //    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                     = 0x00000010,   // Can be used as framebuffer color attachment
@@ -216,7 +216,7 @@
 
     VkMemoryRequirements mem_req;
 
-    VkMemoryAllocInfo mem_info = {};
+    VkMemoryAllocateInfo mem_info = {};
     mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
     mem_info.pNext = NULL;
 
@@ -230,7 +230,7 @@
     ASSERT_TRUE(pass);
 
     /* allocate memory */
-    err = vkAllocMemory(device(), &mem_info, NULL, &m_image_mem);
+    err = vkAllocateMemory(device(), &mem_info, NULL, &m_image_mem);
     ASSERT_VK_SUCCESS(err);
 
     /* bind memory */
@@ -289,9 +289,9 @@
     viewInfo.channels.a = VK_CHANNEL_SWIZZLE_A;
 
     viewInfo.subresourceRange.baseArrayLayer = 0;
-    viewInfo.subresourceRange.numLayers = 1;
+    viewInfo.subresourceRange.layerCount = 1;
     viewInfo.subresourceRange.baseMipLevel = 0;
-    viewInfo.subresourceRange.numLevels = 1;
+    viewInfo.subresourceRange.levelCount = 1;
     viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 
     //    VkResult VKAPI vkCreateImageView(
diff --git a/tests/init.cpp b/tests/init.cpp
index bbb63cc..452c58f 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -94,15 +94,15 @@
 
         this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
         this->app_info.pNext = NULL;
-        this->app_info.pAppName = "base";
-        this->app_info.appVersion = 1;
+        this->app_info.pApplicationName = "base";
+        this->app_info.applicationVersion = 1;
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
         this->app_info.apiVersion = VK_API_VERSION;
         VkInstanceCreateInfo inst_info = {};
         inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
         inst_info.pNext = NULL;
-        inst_info.pAppInfo = &app_info;
+        inst_info.pApplicationInfo = &app_info;
         inst_info.enabledLayerNameCount = 0;
         inst_info.ppEnabledLayerNames = NULL;
         inst_info.enabledExtensionNameCount = 0;
@@ -138,10 +138,10 @@
     }
 };
 
-TEST_F(VkTest, AllocMemory) {
+TEST_F(VkTest, AllocateMemory) {
     VkResult err;
     bool pass;
-    VkMemoryAllocInfo alloc_info = {};
+    VkMemoryAllocateInfo alloc_info = {};
     VkDeviceMemory gpu_mem;
     uint8_t *pData;
 
@@ -155,7 +155,7 @@
     pass = m_device->phy().set_memory_type(((1 << mem_props.memoryTypeCount) - 1), &alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
     ASSERT_TRUE(pass);
 
-    err = vkAllocMemory(device(), &alloc_info, NULL, &gpu_mem);
+    err = vkAllocateMemory(device(), &alloc_info, NULL, &gpu_mem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkMapMemory(device(), gpu_mem, 0, 0, 0, (void **) &pData);
@@ -408,11 +408,11 @@
 
     if (mem_req.size) {
 
-        //        VkResult VKAPI vkAllocMemory(
+        //        VkResult VKAPI vkAllocateMemory(
         //            VkDevice                                  device,
-        //            const VkMemoryAllocInfo*                pAllocInfo,
-        //            VkDeviceMemory*                             pMem);
-        VkMemoryAllocInfo mem_info = {};
+        //            const VkMemoryAllocateInfo*                pAllocateInfo,
+        //            VkDeviceMemory*                             pMemory);
+        VkMemoryAllocateInfo mem_info = {};
 
         mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
         mem_info.pNext = NULL;
@@ -422,7 +422,7 @@
         pass = m_device->phy().set_memory_type(mem_req.memoryTypeBits, &mem_info, 0);
         ASSERT_TRUE(pass);
 
-        err = vkAllocMemory(device(), &mem_info, NULL, &image_mem);
+        err = vkAllocateMemory(device(), &mem_info, NULL, &image_mem);
         ASSERT_VK_SUCCESS(err);
 
         err = vkBindImageMemory(device(), image, image_mem, 0);
@@ -453,9 +453,9 @@
     viewInfo.channels.a = VK_CHANNEL_SWIZZLE_A;
 
     viewInfo.subresourceRange.baseArrayLayer = 0;
-    viewInfo.subresourceRange.numLayers = 1;
+    viewInfo.subresourceRange.layerCount = 1;
     viewInfo.subresourceRange.baseMipLevel = 0;
-    viewInfo.subresourceRange.numLevels = 1;
+    viewInfo.subresourceRange.levelCount = 1;
     viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 
 //    VkResult VKAPI vkCreateImageView(
@@ -484,35 +484,35 @@
 void VkTest::CreateCommandBufferTest()
 {
     VkResult err;
-    VkCmdBufferAllocInfo info = {};
-    VkCmdPool cmdPool;
-    VkCmdBuffer cmdBuffer;
+    VkCommandBufferAllocateInfo info = {};
+    VkCommandPool commandPool;
+    VkCommandBuffer commandBuffer;
 
-//    typedef struct VkCmdBufferCreateInfo_
+//    typedef struct VkCommandBufferCreateInfo_
 //    {
-//        VkStructureType                      sType;      // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO
+//        VkStructureType                      sType;      // Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO
 //        const void*                             pNext;
 //        VK_QUEUE_TYPE                          queueType;
 //        VkFlags                               flags;
-//    } VkCmdBufferAllocInfo;
+//    } VkCommandBufferAllocateInfo;
 
-    VkCmdPoolCreateInfo cmd_pool_info;
-    cmd_pool_info.sType = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO,
+    VkCommandPoolCreateInfo cmd_pool_info;
+    cmd_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
     cmd_pool_info.pNext = NULL,
     cmd_pool_info.queueFamilyIndex = graphics_queue_node_index;
     cmd_pool_info.flags = 0,
-    err = vkCreateCommandPool(device(), &cmd_pool_info, NULL, &cmdPool);
+    err = vkCreateCommandPool(device(), &cmd_pool_info, NULL, &commandPool);
     ASSERT_VK_SUCCESS(err) << "vkCreateCommandPool failed";
 
-    info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO;
-    info.cmdPool = cmdPool;
+    info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO;
+    info.commandPool = commandPool;
     info.bufferCount = 1;
-    info.level = VK_CMD_BUFFER_LEVEL_PRIMARY;
-    err = vkAllocCommandBuffers(device(), &info, &cmdBuffer);
-    ASSERT_VK_SUCCESS(err) << "vkAllocCommandBuffers failed";
+    info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+    err = vkAllocateCommandBuffers(device(), &info, &commandBuffer);
+    ASSERT_VK_SUCCESS(err) << "vkAllocateCommandBuffers failed";
 
-    vkFreeCommandBuffers(device(), cmdPool, 1, &cmdBuffer);
-    vkDestroyCommandPool(device(), cmdPool, NULL);
+    vkFreeCommandBuffers(device(), commandPool, 1, &commandBuffer);
+    vkDestroyCommandPool(device(), commandPool, NULL);
 }
 
 TEST_F(VkTest, TestCommandBuffer) {
diff --git a/tests/layer_test_suite.py b/tests/layer_test_suite.py
index 7a1e678..3b5c6dc 100755
--- a/tests/layer_test_suite.py
+++ b/tests/layer_test_suite.py
@@ -44,21 +44,21 @@
 expected_errors = {'XglRenderTest.CubeWithVertexFetchAndMVP' : ['{OBJTRACK}ERROR : OBJ ERROR : DEPTH_STENCIL_VIEW',
                                                                 '{OBJTRACK}ERROR : OBJ ERROR : GPU_MEMORY',
                                                                 '{OBJTRACK}ERROR : OBJ ERROR : IMAGE'],
-                   'XglRenderTest.CubeWithVertexFetchAndMVPAndTexture' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER',
+                   'XglRenderTest.CubeWithVertexFetchAndMVPAndTexture' : ['{OBJTRACK}ERROR : OBJ ERROR : COMMAND_BUFFER',
                                                                           '{OBJTRACK}ERROR : OBJ ERROR : DEPTH_STENCIL_VIEW',
                                                                           '{OBJTRACK}ERROR : OBJ ERROR : GPU_MEMORY',
                                                                           '{OBJTRACK}ERROR : OBJ ERROR : IMAGE'],
                    'XglTest.Fence' : ['{OBJTRACK}ERROR : OBJECT VALIDATION WARNING: FENCE'],
                    #'XglRenderTest.VKTriangle_OutputLocation' : ['{OBJTRACK}ERROR : vkQueueSubmit Memory reference count'],
-                   'XglRenderTest.TriangleWithVertexFetch' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],
-                   'XglRenderTest.TriangleMRT' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],
-                   'XglRenderTest.QuadWithIndexedVertexFetch' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER', '{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],
-                   'XglRenderTest.GreyandRedCirclesonBlue' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],
-                   'XglRenderTest.RedCirclesonBlue' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],
-                   'XglRenderTest.GreyCirclesonBlueFade' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],
-                   'XglRenderTest.GreyCirclesonBlueDiscard' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],
-                   'XglRenderTest.TriVertFetchAndVertID' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],
-                   'XglRenderTest.TriVertFetchDeadAttr' : ['{OBJTRACK}ERROR : OBJ ERROR : CMD_BUFFER'],}
+                   'XglRenderTest.TriangleWithVertexFetch' : ['{OBJTRACK}ERROR : OBJ ERROR : COMMAND_BUFFER'],
+                   'XglRenderTest.TriangleMRT' : ['{OBJTRACK}ERROR : OBJ ERROR : COMMAND_BUFFER'],
+                   'XglRenderTest.QuadWithIndexedVertexFetch' : ['{OBJTRACK}ERROR : OBJ ERROR : COMMAND_BUFFER', '{OBJTRACK}ERROR : OBJ ERROR : COMMAND_BUFFER'],
+                   'XglRenderTest.GreyandRedCirclesonBlue' : ['{OBJTRACK}ERROR : OBJ ERROR : COMMAND_BUFFER'],
+                   'XglRenderTest.RedCirclesonBlue' : ['{OBJTRACK}ERROR : OBJ ERROR : COMMAND_BUFFER'],
+                   'XglRenderTest.GreyCirclesonBlueFade' : ['{OBJTRACK}ERROR : OBJ ERROR : COMMAND_BUFFER'],
+                   'XglRenderTest.GreyCirclesonBlueDiscard' : ['{OBJTRACK}ERROR : OBJ ERROR : COMMAND_BUFFER'],
+                   'XglRenderTest.TriVertFetchAndVertID' : ['{OBJTRACK}ERROR : OBJ ERROR : COMMAND_BUFFER'],
+                   'XglRenderTest.TriVertFetchDeadAttr' : ['{OBJTRACK}ERROR : OBJ ERROR : COMMAND_BUFFER'],}
 
 # Verify that expected errors are hit
 # Return True if all expected errors for any matched tests are found and no unexpected errors are found
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index b4a3b64..94ef3db 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -147,26 +147,26 @@
 class VkLayerTest : public VkRenderFramework
 {
 public:
-    VkResult BeginCommandBuffer(VkCommandBufferObj &cmdBuffer);
-    VkResult EndCommandBuffer(VkCommandBufferObj &cmdBuffer);
+    VkResult BeginCommandBuffer(VkCommandBufferObj &commandBuffer);
+    VkResult EndCommandBuffer(VkCommandBufferObj &commandBuffer);
     void VKTriangleTest(const char *vertShaderText, const char *fragShaderText, BsoFailSelect failMask);
-    void GenericDrawPreparation(VkCommandBufferObj *cmdBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet, BsoFailSelect failMask);
+    void GenericDrawPreparation(VkCommandBufferObj *commandBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet, BsoFailSelect failMask);
     void GenericDrawPreparation(VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet,  BsoFailSelect failMask)
-             { GenericDrawPreparation(m_cmdBuffer, pipelineobj, descriptorSet, failMask); }
+             { GenericDrawPreparation(m_commandBuffer, pipelineobj, descriptorSet, failMask); }
 
     /* Convenience functions that use built-in command buffer */
-    VkResult BeginCommandBuffer() { return BeginCommandBuffer(*m_cmdBuffer); }
-    VkResult EndCommandBuffer() { return EndCommandBuffer(*m_cmdBuffer); }
+    VkResult BeginCommandBuffer() { return BeginCommandBuffer(*m_commandBuffer); }
+    VkResult EndCommandBuffer() { return EndCommandBuffer(*m_commandBuffer); }
     void Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
-        { m_cmdBuffer->Draw(vertexCount, instanceCount, firstVertex, firstInstance); }
+        { m_commandBuffer->Draw(vertexCount, instanceCount, firstVertex, firstInstance); }
     void DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
-        { m_cmdBuffer->DrawIndexed(indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); }
-    void QueueCommandBuffer() { m_cmdBuffer->QueueCommandBuffer(); }
-    void QueueCommandBuffer(const VkFence& fence) { m_cmdBuffer->QueueCommandBuffer(fence); }
+        { m_commandBuffer->DrawIndexed(indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); }
+    void QueueCommandBuffer() { m_commandBuffer->QueueCommandBuffer(); }
+    void QueueCommandBuffer(const VkFence& fence) { m_commandBuffer->QueueCommandBuffer(fence); }
     void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkDeviceSize offset, uint32_t binding)
-        { m_cmdBuffer->BindVertexBuffer(vertexBuffer, offset, binding); }
+        { m_commandBuffer->BindVertexBuffer(vertexBuffer, offset, binding); }
     void BindIndexBuffer(VkIndexBufferObj *indexBuffer, VkDeviceSize offset)
-        { m_cmdBuffer->BindIndexBuffer(indexBuffer, offset); }
+        { m_commandBuffer->BindIndexBuffer(indexBuffer, offset); }
 protected:
         ErrorMonitor               *m_errorMonitor;
 
@@ -182,7 +182,7 @@
          * any extension / layer that utilizes that feature also needs
          * to be enabled at create instance time.
          */
-        // Use Threading layer first to protect others from ThreadCmdBufferCollision test
+        // Use Threading layer first to protect others from ThreadCommandBufferCollision test
         instance_layer_names.push_back("Threading");
         instance_layer_names.push_back("ObjectTracker");
         instance_layer_names.push_back("MemTracker");
@@ -201,8 +201,8 @@
 
         this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
         this->app_info.pNext = NULL;
-        this->app_info.pAppName = "layer_tests";
-        this->app_info.appVersion = 1;
+        this->app_info.pApplicationName = "layer_tests";
+        this->app_info.applicationVersion = 1;
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
         this->app_info.apiVersion = VK_API_VERSION;
@@ -220,32 +220,32 @@
     }
 };
 
-VkResult VkLayerTest::BeginCommandBuffer(VkCommandBufferObj &cmdBuffer)
+VkResult VkLayerTest::BeginCommandBuffer(VkCommandBufferObj &commandBuffer)
 {
     VkResult result;
 
-    result = cmdBuffer.BeginCommandBuffer();
+    result = commandBuffer.BeginCommandBuffer();
 
     /*
      * For render test all drawing happens in a single render pass
      * on a single command buffer.
      */
     if (VK_SUCCESS == result && renderPass()) {
-        cmdBuffer.BeginRenderPass(renderPassBeginInfo());
+        commandBuffer.BeginRenderPass(renderPassBeginInfo());
     }
 
     return result;
 }
 
-VkResult VkLayerTest::EndCommandBuffer(VkCommandBufferObj &cmdBuffer)
+VkResult VkLayerTest::EndCommandBuffer(VkCommandBufferObj &commandBuffer)
 {
     VkResult result;
 
     if (renderPass()) {
-        cmdBuffer.EndRenderPass();
+        commandBuffer.EndRenderPass();
     }
 
-    result = cmdBuffer.EndCommandBuffer();
+    result = commandBuffer.EndCommandBuffer();
 
     return result;
 }
@@ -345,15 +345,15 @@
     QueueCommandBuffer();
 }
 
-void VkLayerTest::GenericDrawPreparation(VkCommandBufferObj *cmdBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet, BsoFailSelect failMask)
+void VkLayerTest::GenericDrawPreparation(VkCommandBufferObj *commandBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet, BsoFailSelect failMask)
 {
     if (m_depthStencil->Initialized()) {
-        cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, m_depthStencil);
+        commandBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, m_depthStencil);
     } else {
-        cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
+        commandBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
     }
 
-    cmdBuffer->PrepareAttachments();
+    commandBuffer->PrepareAttachments();
     // 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 = {};
@@ -376,11 +376,11 @@
     pipelineobj.SetDepthStencil(&ds_ci);
     pipelineobj.SetViewport(m_viewports);
     pipelineobj.SetScissor(m_scissors);
-    descriptorSet.CreateVKDescriptorSet(cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(commandBuffer);
     VkResult err = pipelineobj.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
     ASSERT_VK_SUCCESS(err);
-    cmdBuffer->BindPipeline(pipelineobj);
-    cmdBuffer->BindDescriptorSet(descriptorSet);
+    commandBuffer->BindPipeline(pipelineobj);
+    commandBuffer->BindDescriptorSet(descriptorSet);
 }
 
 // ********************************************************************************************************************
@@ -388,7 +388,7 @@
 // ********************************************************************************************************************
 // ********************************************************************************************************************
 #if MEM_TRACKER_TESTS
-TEST_F(VkLayerTest, CallResetCmdBufferBeforeCompletion)
+TEST_F(VkLayerTest, CallResetCommandBufferBeforeCompletion)
 {
     vk_testing::Fence testFence;
     VkFlags msgFlags;
@@ -406,7 +406,7 @@
     buffer.init_as_dst(*m_device, (VkDeviceSize)20, reqs);
 
     BeginCommandBuffer();
-    m_cmdBuffer->FillBuffer(buffer.handle(), 0, 4, 0x11111111);
+    m_commandBuffer->FillBuffer(buffer.handle(), 0, 4, 0x11111111);
     EndCommandBuffer();
 
     testFence.init(*m_device, fenceInfo);
@@ -419,7 +419,7 @@
     submit_info.waitSemaphoreCount = 0;
     submit_info.pWaitSemaphores = NULL;
     submit_info.commandBufferCount = 1;
-    submit_info.pCommandBuffers = &m_cmdBuffer->handle();
+    submit_info.pCommandBuffers = &m_commandBuffer->handle();
     submit_info.signalSemaphoreCount = 0;
     submit_info.pSignalSemaphores = NULL;
 
@@ -428,7 +428,7 @@
 
     m_errorMonitor->ClearState();
     // Introduce failure by calling begin again before checking fence
-    vkResetCommandBuffer(m_cmdBuffer->handle(), 0);
+    vkResetCommandBuffer(m_commandBuffer->handle(), 0);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an err after calling ResetCommandBuffer on an active Command Buffer";
@@ -437,7 +437,7 @@
     }
 }
 
-TEST_F(VkLayerTest, CallBeginCmdBufferBeforeCompletion)
+TEST_F(VkLayerTest, CallBeginCommandBufferBeforeCompletion)
 {
     vk_testing::Fence testFence;
     VkFlags msgFlags;
@@ -453,7 +453,7 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
     BeginCommandBuffer();
-    m_cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
+    m_commandBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
     EndCommandBuffer();
 
     testFence.init(*m_device, fenceInfo);
@@ -466,7 +466,7 @@
     submit_info.waitSemaphoreCount = 0;
     submit_info.pWaitSemaphores = NULL;
     submit_info.commandBufferCount = 1;
-    submit_info.pCommandBuffers = &m_cmdBuffer->handle();
+    submit_info.pCommandBuffers = &m_commandBuffer->handle();
     submit_info.signalSemaphoreCount = 0;
     submit_info.pSignalSemaphores = NULL;
 
@@ -475,15 +475,15 @@
 
     m_errorMonitor->ClearState();
 
-    VkCmdBufferBeginInfo info = {};
-    info.flags       = VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-    info.sType       = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    VkCommandBufferBeginInfo info = {};
+    info.flags       = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+    info.sType       = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     info.renderPass  = VK_NULL_HANDLE;
     info.subpass     = 0;
     info.framebuffer = VK_NULL_HANDLE;
 
     // Introduce failure by calling BCB again before checking fence
-    vkBeginCommandBuffer(m_cmdBuffer->handle(), &info);
+    vkBeginCommandBuffer(m_commandBuffer->handle(), &info);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an err after calling BeginCommandBuffer on an active Command Buffer";
@@ -526,7 +526,7 @@
         image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
         image_create_info.flags = 0;
 
-    VkMemoryAllocInfo mem_alloc = {};
+    VkMemoryAllocateInfo mem_alloc = {};
     mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
         mem_alloc.pNext = NULL;
         mem_alloc.allocationSize = 0;
@@ -549,7 +549,7 @@
     }
 
     // allocate memory
-    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
+    err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
     ASSERT_VK_SUCCESS(err);
 
     // Try to bind free memory that has been freed
@@ -602,7 +602,7 @@
 //        .usage           = VK_IMAGE_USAGE_SAMPLED_BIT,
 //        .flags           = 0,
 //    };
-//    VkMemoryAllocInfo mem_alloc = {
+//    VkMemoryAllocateInfo mem_alloc = {
 //        .sType           = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
 //        .pNext           = NULL,
 //        .allocationSize  = 0,
@@ -623,7 +623,7 @@
 //    ASSERT_VK_SUCCESS(err);
 //
 //    // allocate memory
-//    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
+//    err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
 //    ASSERT_VK_SUCCESS(err);
 //
 //    // Bind memory to Image object
@@ -675,7 +675,7 @@
         image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
         image_create_info.flags = 0;
 
-    VkMemoryAllocInfo mem_alloc = {};
+    VkMemoryAllocateInfo mem_alloc = {};
         mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
         mem_alloc.pNext = NULL;
         mem_alloc.allocationSize = 0;
@@ -695,9 +695,9 @@
     ASSERT_TRUE(pass);
 
     // allocate 2 memory objects
-    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem1);
+    err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem1);
     ASSERT_VK_SUCCESS(err);
-    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem2);
+    err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem2);
     ASSERT_VK_SUCCESS(err);
 
     // Bind first memory object to Image object
@@ -734,7 +734,7 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
     BeginCommandBuffer();
-    m_cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
+    m_commandBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
     EndCommandBuffer();
 
     testFence.init(*m_device, fenceInfo);
@@ -746,7 +746,7 @@
     submit_info.waitSemaphoreCount = 0;
     submit_info.pWaitSemaphores = NULL;
     submit_info.commandBufferCount = 1;
-    submit_info.pCommandBuffers = &m_cmdBuffer->handle();
+    submit_info.pCommandBuffers = &m_commandBuffer->handle();
     submit_info.signalSemaphoreCount = 0;
     submit_info.pSignalSemaphores = NULL;
 
@@ -793,7 +793,7 @@
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
-    VkCommandBufferObj cmdBuffer(m_device);
+    VkCommandBufferObj commandBuffer(m_device);
     BeginCommandBuffer();
 
     const VkExtent3D e3d = {
@@ -880,12 +880,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -901,10 +901,10 @@
     VkPipeline badPipeline = (VkPipeline)0xbaadb1be;
 
     BeginCommandBuffer();
-    vkCmdBindPipeline(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, badPipeline);
+    vkCmdBindPipeline(m_commandBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, badPipeline);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
-    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after binding invalid pipeline to CmdBuffer";
+    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after binding invalid pipeline to CommandBuffer";
     if (!strstr(msgString.c_str(),"Invalid VkPipeline Object ")) {
         FAIL() << "Error received was not 'Invalid VkPipeline Object 0xbaadb1be' but instead it was '" << msgString.c_str() << "'";
     }
@@ -948,7 +948,7 @@
         image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
         image_create_info.flags = 0;
 
-    VkMemoryAllocInfo mem_alloc = {};
+    VkMemoryAllocateInfo mem_alloc = {};
         mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
         mem_alloc.pNext = NULL;
         mem_alloc.allocationSize = 0;
@@ -967,7 +967,7 @@
     ASSERT_TRUE(pass);
 
     // allocate memory
-    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
+    err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
     ASSERT_VK_SUCCESS(err);
 
     // Introduce validation failure, free memory before binding
@@ -1021,7 +1021,7 @@
         image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
         image_create_info.flags = 0;
 
-    VkMemoryAllocInfo mem_alloc = {};
+    VkMemoryAllocateInfo mem_alloc = {};
         mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
         mem_alloc.pNext = NULL;
         mem_alloc.allocationSize = 0;
@@ -1039,7 +1039,7 @@
     ASSERT_TRUE(pass);
 
     // Allocate memory
-    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
+    err = vkAllocateMemory(m_device->device(), &mem_alloc, NULL, &mem);
     ASSERT_VK_SUCCESS(err);
 
     // Introduce validation failure, destroy Image object before binding
@@ -1100,12 +1100,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkBufferView view = (VkBufferView) 0xbaadbeef; // invalid bufferView object
@@ -1113,8 +1113,8 @@
     VkWriteDescriptorSet descriptor_write;
     memset(&descriptor_write, 0, sizeof(descriptor_write));
     descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    descriptor_write.destSet = descriptorSet;
-    descriptor_write.destBinding = 0;
+    descriptor_write.dstSet = descriptorSet;
+    descriptor_write.dstBinding = 0;
     descriptor_write.descriptorCount = 1;
     descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
     descriptor_write.pTexelBufferView = &view;
@@ -1283,7 +1283,7 @@
     }
 }
 
-TEST_F(VkLayerTest, CmdBufferTwoSubmits)
+TEST_F(VkLayerTest, CommandBufferTwoSubmits)
 {
     vk_testing::Fence testFence;
     VkFlags msgFlags;
@@ -1298,9 +1298,9 @@
     ASSERT_NO_FATAL_FAILURE(InitViewport());
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
-    // We luck out b/c by default the framework creates CB w/ the VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set
+    // We luck out b/c by default the framework creates CB w/ the VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set
     BeginCommandBuffer();
-    m_cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
+    m_commandBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
     EndCommandBuffer();
 
     testFence.init(*m_device, fenceInfo);
@@ -1313,7 +1313,7 @@
     submit_info.waitSemaphoreCount = 0;
     submit_info.pWaitSemaphores = NULL;
     submit_info.commandBufferCount = 1;
-    submit_info.pCommandBuffers = &m_cmdBuffer->handle();
+    submit_info.pCommandBuffers = &m_commandBuffer->handle();
     submit_info.signalSemaphoreCount = 0;
     submit_info.pSignalSemaphores = NULL;
 
@@ -1326,8 +1326,8 @@
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an err after re-submitting Command Buffer that was created with one-time submit flag";
-    if (!strstr(msgString.c_str(),"was begun w/ VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted")) {
-        FAIL() << "Error received was not 'CB (0xaddress) was created w/ VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set...'";
+    if (!strstr(msgString.c_str(),"was begun w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted")) {
+        FAIL() << "Error received was not 'CB (0xaddress) was created w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set...'";
     }
 }
 
@@ -1374,17 +1374,17 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
     VkPipelineMultisampleStateCreateInfo pipe_ms_state_ci = {};
         pipe_ms_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
         pipe_ms_state_ci.pNext = NULL;
-        pipe_ms_state_ci.rasterSamples = 1;
+        pipe_ms_state_ci.rasterizationSamples = 1;
         pipe_ms_state_ci.sampleShadingEnable = 0;
         pipe_ms_state_ci.minSampleShading = 1.0;
         pipe_ms_state_ci.pSampleMask = NULL;
@@ -1408,18 +1408,18 @@
     pipe.SetMSAA(&pipe_ms_state_ci);
     pipe.CreateVKPipeline(pipeline_layout, renderPass());
     m_errorMonitor->ClearState();
-    // Calls AllocCommandBuffers
-    VkCommandBufferObj cmdBuffer(m_device, m_cmdPool);
-    VkCmdBufferBeginInfo cmd_buf_info = {};
-    memset(&cmd_buf_info, 0, sizeof(VkCmdBufferBeginInfo));
-    cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    // Calls AllocateCommandBuffers
+    VkCommandBufferObj commandBuffer(m_device, m_commandPool);
+    VkCommandBufferBeginInfo cmd_buf_info = {};
+    memset(&cmd_buf_info, 0, sizeof(VkCommandBufferBeginInfo));
+    cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     cmd_buf_info.pNext = NULL;
-    cmd_buf_info.flags = VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+    cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 
-    vkBeginCommandBuffer(cmdBuffer.GetBufferHandle(), &cmd_buf_info);
-    vkCmdBindPipeline(cmdBuffer.GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
+    vkBeginCommandBuffer(commandBuffer.GetBufferHandle(), &cmd_buf_info);
+    vkCmdBindPipeline(commandBuffer.GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
     msgFlags = m_errorMonitor->GetState(&msgString);
-    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after binding pipeline to CmdBuffer w/o active RenderPass";
+    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after binding pipeline to CommandBuffer w/o active RenderPass";
     if (!strstr(msgString.c_str(),"Incorrectly binding graphics pipeline ")) {
         FAIL() << "Error received was not 'Incorrectly binding graphics pipeline (0x<handle>) without an active RenderPass' but rather '" << msgString.c_str() << "'";
     }
@@ -1474,12 +1474,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after alloc descriptor from pool w/o requested type";
@@ -1536,12 +1536,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     err = vkFreeDescriptorSets(m_device->device(), ds_pool, 1, &descriptorSet);
@@ -1598,12 +1598,12 @@
 //
 //    ASSERT_NO_FATAL_FAILURE(InitState());
 //    m_errorMonitor->ClearState();
-//    VkCommandBufferObj cmdBuffer(m_device);
+//    VkCommandBufferObj commandBuffer(m_device);
 //    BeginCommandBuffer();
 //    VkPipeline badPipeline = (VkPipeline)0xbaadb1be;
-//    vkCmdBindPipeline(cmdBuffer.GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, badPipeline);
+//    vkCmdBindPipeline(commandBuffer.GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, badPipeline);
 //    msgFlags = m_errorMonitor->GetState(&msgString);
-//    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after binding invalid pipeline to CmdBuffer";
+//    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after binding invalid pipeline to CommandBuffer";
 //    if (!strstr(msgString.c_str(),"Attempt to bind Pipeline ")) {
 //        FAIL() << "Error received was not 'Attempt to bind Pipeline 0xbaadb1be that doesn't exist!'";
 //    }
@@ -1611,7 +1611,7 @@
 
 TEST_F(VkLayerTest, DescriptorSetNotUpdated)
 {
-    // Create and update CmdBuffer then call QueueSubmit w/o calling End on CmdBuffer
+    // Create and update CommandBuffer then call QueueSubmit w/o calling End on CommandBuffer
     VkFlags         msgFlags;
     std::string     msgString;
     VkResult        err;
@@ -1651,12 +1651,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -1679,8 +1679,8 @@
     pipe.CreateVKPipeline(pipeline_layout, renderPass());
 
     BeginCommandBuffer();
-    vkCmdBindPipeline(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
-    vkCmdBindDescriptorSets(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &descriptorSet, 0, NULL);
+    vkCmdBindPipeline(m_commandBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
+    vkCmdBindDescriptorSets(m_commandBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, &descriptorSet, 0, NULL);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_NE(0, msgFlags & VK_DBG_REPORT_WARN_BIT) << "Did not warn after binding a DescriptorSet that was never updated.";
@@ -1693,24 +1693,24 @@
     vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
-TEST_F(VkLayerTest, NoBeginCmdBuffer)
+TEST_F(VkLayerTest, NoBeginCommandBuffer)
 {
     VkFlags         msgFlags;
     std::string     msgString;
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
-    VkCommandBufferObj cmdBuffer(m_device, m_cmdPool);
+    VkCommandBufferObj commandBuffer(m_device, m_commandPool);
     // Call EndCommandBuffer() w/o calling BeginCommandBuffer()
-    vkEndCommandBuffer(cmdBuffer.GetBufferHandle());
+    vkEndCommandBuffer(commandBuffer.GetBufferHandle());
     msgFlags = m_errorMonitor->GetState(&msgString);
-    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after ending a CmdBuffer w/o calling BeginCommandBuffer()";
+    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after ending a CommandBuffer w/o calling BeginCommandBuffer()";
     if (!strstr(msgString.c_str(),"You must call vkBeginCommandBuffer() before this call to ")) {
         FAIL() << "Error received was not 'You must call vkBeginCommandBuffer() before this call to vkEndCommandBuffer()'";
     }
 }
 
-TEST_F(VkLayerTest, PrimaryCmdBufferFramebufferAndRenderpass)
+TEST_F(VkLayerTest, PrimaryCommandBufferFramebufferAndRenderpass)
 {
     VkFlags         msgFlags;
     std::string     msgString;
@@ -1718,53 +1718,53 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
 
-    // Calls AllocCommandBuffers
-    VkCommandBufferObj cmdBuffer(m_device, m_cmdPool);
+    // Calls AllocateCommandBuffers
+    VkCommandBufferObj commandBuffer(m_device, m_commandPool);
 
     // Force the failure by setting the Renderpass and Framebuffer fields with (fake) data
-    VkCmdBufferBeginInfo cmd_buf_info = {};
-    cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    VkCommandBufferBeginInfo cmd_buf_info = {};
+    cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     cmd_buf_info.pNext = NULL;
-    cmd_buf_info.flags = VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+    cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
     cmd_buf_info.renderPass = (VkRenderPass)0xcadecade;
     cmd_buf_info.framebuffer = (VkFramebuffer)0xcadecade;
 
 
     // The error should be caught by validation of the BeginCommandBuffer call
-    vkBeginCommandBuffer(cmdBuffer.GetBufferHandle(), &cmd_buf_info);
+    vkBeginCommandBuffer(commandBuffer.GetBufferHandle(), &cmd_buf_info);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error passing a non-NULL Framebuffer and Renderpass to BeginCommandBuffer()";
     if (!strstr(msgString.c_str(),"may not specify framebuffer or renderpass parameters")) {
-        FAIL() << "Error received was not 'vkAllocCommandBuffers():  Primary Command Buffer may not specify framebuffer or renderpass parameters'";
+        FAIL() << "Error received was not 'vkAllocateCommandBuffers():  Primary Command Buffer may not specify framebuffer or renderpass parameters'";
     }
 }
 
-TEST_F(VkLayerTest, SecondaryCmdBufferFramebufferAndRenderpass)
+TEST_F(VkLayerTest, SecondaryCommandBufferFramebufferAndRenderpass)
 {
     VkFlags         msgFlags;
     std::string     msgString;
     VkResult        err;
-    VkCmdBuffer     draw_cmd;
+    VkCommandBuffer     draw_cmd;
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
 
-    VkCmdBufferAllocInfo cmd = {};
-    cmd.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO;
+    VkCommandBufferAllocateInfo cmd = {};
+    cmd.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO;
     cmd.pNext = NULL;
-    cmd.cmdPool = m_cmdPool;
-    cmd.level = VK_CMD_BUFFER_LEVEL_SECONDARY;
+    cmd.commandPool = m_commandPool;
+    cmd.level = VK_COMMAND_BUFFER_LEVEL_SECONDARY;
     cmd.bufferCount = 1;
 
-    err = vkAllocCommandBuffers(m_device->device(), &cmd, &draw_cmd);
+    err = vkAllocateCommandBuffers(m_device->device(), &cmd, &draw_cmd);
     ASSERT_VK_SUCCESS(err);
 
     // Force the failure by not setting the Renderpass and Framebuffer fields
-    VkCmdBufferBeginInfo cmd_buf_info = {};
-    cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    VkCommandBufferBeginInfo cmd_buf_info = {};
+    cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     cmd_buf_info.pNext = NULL;
-    cmd_buf_info.flags = VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+    cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 
     // The error should be caught by validation of the BeginCommandBuffer call
     vkBeginCommandBuffer(draw_cmd, &cmd_buf_info);
@@ -1772,9 +1772,9 @@
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error passing NULL Framebuffer/Renderpass to BeginCommandBuffer()";
     if (!strstr(msgString.c_str(),"must specify framebuffer and renderpass parameters")) {
-        FAIL() << "Error received was not 'vkAllocCommandBuffers():  Secondary Command Buffer must specify framebuffer and renderpass parameters'";
+        FAIL() << "Error received was not 'vkAllocateCommandBuffers():  Secondary Command Buffer must specify framebuffer and renderpass parameters'";
     }
-    vkFreeCommandBuffers(m_device->device(), m_cmdPool, 1, &draw_cmd);
+    vkFreeCommandBuffers(m_device->device(), m_commandPool, 1, &draw_cmd);
 }
 
 TEST_F(VkLayerTest, InvalidPipelineCreateState)
@@ -1820,12 +1820,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -1920,7 +1920,7 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_NON_FREE, 1, &ds_layout, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_NON_FREE, 1, &ds_layout, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -1968,7 +1968,7 @@
         gp_ci.pInputAssemblyState = &iaCI;
         gp_ci.pTessellationState = &tsCI;
         gp_ci.pViewportState = NULL;
-        gp_ci.pRasterState = NULL;
+        gp_ci.pRasterizationState = NULL;
         gp_ci.pMultisampleState = NULL;
         gp_ci.pDepthStencilState = NULL;
         gp_ci.pColorBlendState = NULL;
@@ -2043,12 +2043,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -2152,12 +2152,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -2260,12 +2260,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -2315,7 +2315,7 @@
 	ia_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
 	ia_ci.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
 
-	VkPipelineRasterStateCreateInfo rs_ci = {};
+	VkPipelineRasterizationStateCreateInfo rs_ci = {};
 	rs_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO;
 	rs_ci.pNext = nullptr;
 
@@ -2330,7 +2330,7 @@
         gp_ci.pVertexInputState = &vi_ci;
         gp_ci.pInputAssemblyState = &ia_ci;
         gp_ci.pViewportState = &vp_state_ci;
-        gp_ci.pRasterState = &rs_ci;
+        gp_ci.pRasterizationState = &rs_ci;
         gp_ci.pColorBlendState = &cb_ci;
         gp_ci.pDynamicState = &dyn_state_ci;
         gp_ci.flags = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT;
@@ -2360,10 +2360,10 @@
     err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
     ASSERT_VK_SUCCESS(err);
     BeginCommandBuffer();
-    vkCmdBindPipeline(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+    vkCmdBindPipeline(m_commandBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
     VkRect2D scissors[2] = {}; // don't care about data
     // Count of 2 doesn't match PSO count of 1
-    vkCmdSetScissor(m_cmdBuffer->GetBufferHandle(), 2, scissors);
+    vkCmdSetScissor(m_commandBuffer->GetBufferHandle(), 2, scissors);
     Draw(1, 0, 0, 0);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
@@ -2418,12 +2418,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -2473,7 +2473,7 @@
     ia_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
     ia_ci.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
 
-    VkPipelineRasterStateCreateInfo rs_ci = {};
+    VkPipelineRasterizationStateCreateInfo rs_ci = {};
     rs_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO;
     rs_ci.pNext = nullptr;
 
@@ -2488,7 +2488,7 @@
         gp_ci.pVertexInputState = &vi_ci;
         gp_ci.pInputAssemblyState = &ia_ci;
         gp_ci.pViewportState = &vp_state_ci;
-        gp_ci.pRasterState = &rs_ci;
+        gp_ci.pRasterizationState = &rs_ci;
         gp_ci.pColorBlendState = &cb_ci;
         gp_ci.pDynamicState = &dyn_state_ci;
         gp_ci.flags = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT;
@@ -2518,10 +2518,10 @@
     err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
     ASSERT_VK_SUCCESS(err);
     BeginCommandBuffer();
-    vkCmdBindPipeline(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+    vkCmdBindPipeline(m_commandBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
     VkViewport viewports[2] = {}; // don't care about data
     // Count of 2 doesn't match PSO count of 1
-    vkCmdSetViewport(m_cmdBuffer->GetBufferHandle(), 2, viewports);
+    vkCmdSetViewport(m_commandBuffer->GetBufferHandle(), 2, viewports);
     Draw(1, 0, 0, 0);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
@@ -2548,7 +2548,7 @@
 
     BeginCommandBuffer();
     // Don't care about RenderPass handle b/c error should be flagged before that
-    vkCmdBeginRenderPass(m_cmdBuffer->GetBufferHandle(), NULL, VK_RENDER_PASS_CONTENTS_INLINE);
+    vkCmdBeginRenderPass(m_commandBuffer->GetBufferHandle(), NULL, VK_RENDER_PASS_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_cmdBuffer->GetBufferHandle(), &rp_begin, VK_RENDER_PASS_CONTENTS_INLINE);
+    vkCmdBeginRenderPass(m_commandBuffer->GetBufferHandle(), &rp_begin, VK_RENDER_PASS_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.";
@@ -2598,10 +2598,10 @@
     BeginCommandBuffer();
 
     VkMemoryPropertyFlags reqs = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
-    vk_testing::Buffer destBuffer;
-    destBuffer.init_as_dst(*m_device, (VkDeviceSize)1024, reqs);
+    vk_testing::Buffer dstBuffer;
+    dstBuffer.init_as_dst(*m_device, (VkDeviceSize)1024, reqs);
 
-    m_cmdBuffer->FillBuffer(destBuffer.handle(), 0, 4, 0x11111111);
+    m_commandBuffer->FillBuffer(dstBuffer.handle(), 0, 4, 0x11111111);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) <<
@@ -2625,14 +2625,14 @@
     BeginCommandBuffer();
 
     VkMemoryPropertyFlags reqs = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
-    vk_testing::Buffer destBuffer;
-    destBuffer.init_as_dst(*m_device, (VkDeviceSize)1024, reqs);
+    vk_testing::Buffer dstBuffer;
+    dstBuffer.init_as_dst(*m_device, (VkDeviceSize)1024, reqs);
 
-    VkDeviceSize    destOffset = 0;
+    VkDeviceSize    dstOffset = 0;
     VkDeviceSize    dataSize   = 1024;
     const uint32_t *pData      = NULL;
 
-    vkCmdUpdateBuffer(m_cmdBuffer->GetBufferHandle(), destBuffer.handle(), destOffset, dataSize, pData);
+    vkCmdUpdateBuffer(m_commandBuffer->GetBufferHandle(), dstBuffer.handle(), dstOffset, dataSize, pData);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) <<
@@ -2674,14 +2674,14 @@
     image_create_info.tiling                = VK_IMAGE_TILING_LINEAR;
     image_create_info.usage                 = VK_IMAGE_USAGE_SAMPLED_BIT;
 
-    vk_testing::Image destImage;
-    destImage.init(*m_device, (const VkImageCreateInfo&)image_create_info, reqs);
+    vk_testing::Image dstImage;
+    dstImage.init(*m_device, (const VkImageCreateInfo&)image_create_info, reqs);
 
     const VkImageSubresourceRange range =
         vk_testing::Image::subresource_range(image_create_info, VK_IMAGE_ASPECT_COLOR_BIT);
 
-    vkCmdClearColorImage(m_cmdBuffer->GetBufferHandle(),
-                         destImage.handle(),
+    vkCmdClearColorImage(m_commandBuffer->GetBufferHandle(),
+                         dstImage.handle(),
                          VK_IMAGE_LAYOUT_GENERAL,
                          &clear_color,
                          1,
@@ -2718,14 +2718,14 @@
     image_create_info.tiling             = VK_IMAGE_TILING_OPTIMAL;
     image_create_info.usage              = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
 
-    vk_testing::Image destImage;
-    destImage.init(*m_device, (const VkImageCreateInfo&)image_create_info, reqs);
+    vk_testing::Image dstImage;
+    dstImage.init(*m_device, (const VkImageCreateInfo&)image_create_info, reqs);
 
     const VkImageSubresourceRange range =
         vk_testing::Image::subresource_range(image_create_info, VK_IMAGE_ASPECT_DEPTH_BIT);
 
-    vkCmdClearDepthStencilImage(m_cmdBuffer->GetBufferHandle(),
-                                destImage.handle(),
+    vkCmdClearDepthStencilImage(m_commandBuffer->GetBufferHandle(),
+                                dstImage.handle(),
                                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
                                 &clear_value,
                                 1,
@@ -2751,7 +2751,7 @@
     m_errorMonitor->ClearState();
 
     // Start no RenderPass
-    err = m_cmdBuffer->BeginCommandBuffer();
+    err = m_commandBuffer->BeginCommandBuffer();
     ASSERT_VK_SUCCESS(err);
 
     VkClearAttachment color_attachment;
@@ -2762,7 +2762,7 @@
     color_attachment.clearValue.color.float32[3] = 0;
     color_attachment.colorAttachment = 0;
     VkClearRect clear_rect  = { { { 0, 0 }, { 32, 32 } } };
-    vkCmdClearAttachments(m_cmdBuffer->GetBufferHandle(),
+    vkCmdClearAttachments(m_commandBuffer->GetBufferHandle(),
                           1, &color_attachment,
                           1, &clear_rect);
 
@@ -2806,9 +2806,9 @@
 
     BeginCommandBuffer();
     ASSERT_VK_SUCCESS(err);
-    //vkCmdBindPipeline(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
+    //vkCmdBindPipeline(m_commandBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
     // Should error before calling to driver so don't care about actual data
-    vkCmdBindIndexBuffer(m_cmdBuffer->GetBufferHandle(), ib, 7, VK_INDEX_TYPE_UINT16);
+    vkCmdBindIndexBuffer(m_commandBuffer->GetBufferHandle(), ib, 7, VK_INDEX_TYPE_UINT16);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after vkCmdBindVertexBuffers() w/o active RenderPass.";
@@ -2831,8 +2831,8 @@
 
     BeginCommandBuffer();
     //ASSERT_VK_SUCCESS(err);
-    VkCmdBuffer primCB = m_cmdBuffer->GetBufferHandle();
-    vkCmdExecuteCommands(m_cmdBuffer->GetBufferHandle(), 1, &primCB);
+    VkCommandBuffer primCB = m_commandBuffer->GetBufferHandle();
+    vkCmdExecuteCommands(m_commandBuffer->GetBufferHandle(), 1, &primCB);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after vkCmdBindVertexBuffers() w/o active RenderPass.";
@@ -2882,12 +2882,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkSamplerCreateInfo sampler_ci = {};
@@ -2918,7 +2918,7 @@
     VkWriteDescriptorSet descriptor_write;
     memset(&descriptor_write, 0, sizeof(descriptor_write));
     descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    descriptor_write.destSet = descriptorSet;
+    descriptor_write.dstSet = descriptorSet;
     descriptor_write.descriptorCount = 1;
     // This is a mismatched type for the layout which expects BUFFER
     descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
@@ -2979,12 +2979,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkSamplerCreateInfo sampler_ci = {};
@@ -3015,8 +3015,8 @@
     VkWriteDescriptorSet descriptor_write;
     memset(&descriptor_write, 0, sizeof(descriptor_write));
     descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    descriptor_write.destSet = descriptorSet;
-    descriptor_write.destArrayElement = 1; /* This index out of bounds for the update */
+    descriptor_write.dstSet = descriptorSet;
+    descriptor_write.dstArrayElement = 1; /* This index out of bounds for the update */
     descriptor_write.descriptorCount = 1;
     // This is the wrong type, but out of bounds will be flagged first
     descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
@@ -3076,12 +3076,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkSamplerCreateInfo sampler_ci = {};
@@ -3112,8 +3112,8 @@
     VkWriteDescriptorSet descriptor_write;
     memset(&descriptor_write, 0, sizeof(descriptor_write));
     descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    descriptor_write.destSet = descriptorSet;
-    descriptor_write.destBinding = 2;
+    descriptor_write.dstSet = descriptorSet;
+    descriptor_write.dstBinding = 2;
     descriptor_write.descriptorCount = 1;
     // This is the wrong type, but out of bounds will be flagged first
     descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
@@ -3173,12 +3173,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkSamplerCreateInfo sampler_ci = {};
@@ -3209,7 +3209,7 @@
     VkWriteDescriptorSet descriptor_write;
     memset(&descriptor_write, 0, sizeof(descriptor_write));
     descriptor_write.sType = (VkStructureType)0x99999999; /* Intentionally broken struct type */
-    descriptor_write.destSet = descriptorSet;
+    descriptor_write.dstSet = descriptorSet;
     descriptor_write.descriptorCount = 1;
     // This is the wrong type, but out of bounds will be flagged first
     descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
@@ -3269,12 +3269,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkSampler sampler = (VkSampler) 0xbaadbeef; // Sampler with invalid handle
@@ -3286,8 +3286,8 @@
     VkWriteDescriptorSet descriptor_write;
     memset(&descriptor_write, 0, sizeof(descriptor_write));
     descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    descriptor_write.destSet = descriptorSet;
-    descriptor_write.destBinding = 0;
+    descriptor_write.dstSet = descriptorSet;
+    descriptor_write.dstBinding = 0;
     descriptor_write.descriptorCount = 1;
     descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
     descriptor_write.pImageInfo = &descriptor_info;
@@ -3344,12 +3344,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkSamplerCreateInfo sampler_ci = {};
@@ -3384,8 +3384,8 @@
     VkWriteDescriptorSet descriptor_write;
     memset(&descriptor_write, 0, sizeof(descriptor_write));
     descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    descriptor_write.destSet = descriptorSet;
-    descriptor_write.destBinding = 0;
+    descriptor_write.dstSet = descriptorSet;
+    descriptor_write.dstBinding = 0;
     descriptor_write.descriptorCount = 1;
     descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
     descriptor_write.pImageInfo = &descriptor_info;
@@ -3450,12 +3450,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkSamplerCreateInfo sampler_ci = {};
@@ -3486,8 +3486,8 @@
     VkWriteDescriptorSet descriptor_write;
     memset(&descriptor_write, 0, sizeof(VkWriteDescriptorSet));
     descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    descriptor_write.destSet = descriptorSet;
-    descriptor_write.destBinding = 1; // SAMPLER binding from layout above
+    descriptor_write.dstSet = descriptorSet;
+    descriptor_write.dstBinding = 1; // SAMPLER binding from layout above
     descriptor_write.descriptorCount = 1;
     descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
     descriptor_write.pImageInfo = &info;
@@ -3499,8 +3499,8 @@
     copy_ds_update.sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
     copy_ds_update.srcSet = descriptorSet;
     copy_ds_update.srcBinding = 1; // copy from SAMPLER binding
-    copy_ds_update.destSet = descriptorSet;
-    copy_ds_update.destBinding = 0; // ERROR : copy to UNIFORM binding
+    copy_ds_update.dstSet = descriptorSet;
+    copy_ds_update.dstBinding = 0; // ERROR : copy to UNIFORM binding
     copy_ds_update.descriptorCount = 1; // copy 1 descriptor
     vkUpdateDescriptorSets(m_device->device(), 0, NULL, 1, &copy_ds_update);
 
@@ -3514,8 +3514,8 @@
     copy_ds_update.sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
     copy_ds_update.srcSet = descriptorSet;
     copy_ds_update.srcBinding = 3; // ERROR : Invalid binding for matching layout
-    copy_ds_update.destSet = descriptorSet;
-    copy_ds_update.destBinding = 0;
+    copy_ds_update.dstSet = descriptorSet;
+    copy_ds_update.dstBinding = 0;
     copy_ds_update.descriptorCount = 1; // copy 1 descriptor
     vkUpdateDescriptorSets(m_device->device(), 0, NULL, 1, &copy_ds_update);
 
@@ -3529,8 +3529,8 @@
     copy_ds_update.sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
     copy_ds_update.srcSet = descriptorSet;
     copy_ds_update.srcBinding = 1;
-    copy_ds_update.destSet = descriptorSet;
-    copy_ds_update.destBinding = 0;
+    copy_ds_update.dstSet = descriptorSet;
+    copy_ds_update.dstBinding = 0;
     copy_ds_update.descriptorCount = 5; // ERROR copy 5 descriptors (out of bounds for layout)
     vkUpdateDescriptorSets(m_device->device(), 0, NULL, 1, &copy_ds_update);
 
@@ -3547,7 +3547,7 @@
 
 TEST_F(VkLayerTest, NumSamplesMismatch)
 {
-    // Create CmdBuffer where MSAA samples doesn't match RenderPass sampleCount
+    // Create CommandBuffer where MSAA samples doesn't match RenderPass sampleCount
     VkFlags         msgFlags;
     std::string     msgString;
     VkResult        err;
@@ -3587,18 +3587,18 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineMultisampleStateCreateInfo pipe_ms_state_ci = {};
         pipe_ms_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
         pipe_ms_state_ci.pNext = NULL;
-        pipe_ms_state_ci.rasterSamples = 4;
+        pipe_ms_state_ci.rasterizationSamples = 4;
         pipe_ms_state_ci.sampleShadingEnable = 0;
         pipe_ms_state_ci.minSampleShading = 1.0;
         pipe_ms_state_ci.pSampleMask = NULL;
@@ -3623,7 +3623,7 @@
     pipe.CreateVKPipeline(pipeline_layout, renderPass());
 
     BeginCommandBuffer();
-    vkCmdBindPipeline(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
+    vkCmdBindPipeline(m_commandBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after binding RenderPass w/ mismatched MSAA from PSO.";
@@ -3638,7 +3638,7 @@
 
 TEST_F(VkLayerTest, ClearCmdNoDraw)
 {
-    // Create CmdBuffer where we add ClearCmd for FB Color attachment prior to issuing a Draw
+    // Create CommandBuffer where we add ClearCmd for FB Color attachment prior to issuing a Draw
     VkFlags         msgFlags;
     std::string     msgString;
     VkResult        err;
@@ -3679,18 +3679,18 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineMultisampleStateCreateInfo pipe_ms_state_ci = {};
         pipe_ms_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
         pipe_ms_state_ci.pNext = NULL;
-        pipe_ms_state_ci.rasterSamples = 4;
+        pipe_ms_state_ci.rasterizationSamples = 4;
         pipe_ms_state_ci.sampleShadingEnable = 0;
         pipe_ms_state_ci.minSampleShading = 1.0;
         pipe_ms_state_ci.pSampleMask = NULL;
@@ -3728,7 +3728,7 @@
     color_attachment.colorAttachment = 0;
     VkClearRect clear_rect = { { { 0, 0 }, { (int)m_width, (int)m_height } } };
 
-    vkCmdClearAttachments(m_cmdBuffer->GetBufferHandle(), 1, &color_attachment, 1, &clear_rect);
+    vkCmdClearAttachments(m_commandBuffer->GetBufferHandle(), 1, &color_attachment, 1, &clear_rect);
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_NE(0, msgFlags & VK_DBG_REPORT_WARN_BIT) << "Did not receive error after issuing Clear Cmd on FB color attachment prior to Draw Cmd.";
     if (!strstr(msgString.c_str(),"vkCmdClearAttachments() issued on CB object ")) {
@@ -3742,7 +3742,7 @@
 
 TEST_F(VkLayerTest, VtxBufferBadIndex)
 {
-    // Create CmdBuffer where MSAA samples doesn't match RenderPass sampleCount
+    // Create CommandBuffer where MSAA samples doesn't match RenderPass sampleCount
     VkFlags         msgFlags;
     std::string     msgString;
     VkResult        err;
@@ -3784,18 +3784,18 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineMultisampleStateCreateInfo pipe_ms_state_ci = {};
         pipe_ms_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
         pipe_ms_state_ci.pNext = NULL;
-        pipe_ms_state_ci.rasterSamples = 1;
+        pipe_ms_state_ci.rasterizationSamples = 1;
         pipe_ms_state_ci.sampleShadingEnable = 0;
         pipe_ms_state_ci.minSampleShading = 1.0;
         pipe_ms_state_ci.pSampleMask = NULL;
@@ -3822,7 +3822,7 @@
     pipe.CreateVKPipeline(pipeline_layout, renderPass());
 
     BeginCommandBuffer();
-    vkCmdBindPipeline(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
+    vkCmdBindPipeline(m_commandBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
     // Don't care about actual data, just need to get to draw to flag error
     static const float vbo_data[3] = {1.f, 0.f, 1.f};
     VkConstantBufferObj vbo(m_device, sizeof(vbo_data), sizeof(float), (const void*) &vbo_data);
@@ -3844,7 +3844,7 @@
 #if THREADING_TESTS
 #if GTEST_IS_THREADSAFE
 struct thread_data_struct {
-    VkCmdBuffer cmdBuffer;
+    VkCommandBuffer commandBuffer;
     VkEvent event;
     bool bailout;
 };
@@ -3855,7 +3855,7 @@
     std::string msgString;
 
     for (int i = 0; i<10000; i++) {
-        vkCmdSetEvent(data->cmdBuffer, data->event, VK_PIPELINE_STAGE_ALL_GPU_COMMANDS);
+        vkCmdSetEvent(data->commandBuffer, data->event, VK_PIPELINE_STAGE_ALL_GPU_COMMANDS);
         if (data->bailout) {
             break;
         }
@@ -3863,7 +3863,7 @@
     return NULL;
 }
 
-TEST_F(VkLayerTest, ThreadCmdBufferCollision)
+TEST_F(VkLayerTest, ThreadCommandBufferCollision)
 {
     VkFlags msgFlags;
     std::string msgString;
@@ -3875,11 +3875,11 @@
 
     m_errorMonitor->ClearState();
 
-    // Calls AllocCommandBuffers
-    VkCommandBufferObj cmdBuffer(m_device, m_cmdPool);
+    // Calls AllocateCommandBuffers
+    VkCommandBufferObj commandBuffer(m_device, m_commandPool);
 
     // Avoid creating RenderPass
-    cmdBuffer.BeginCommandBuffer();
+    commandBuffer.BeginCommandBuffer();
 
     VkEventCreateInfo event_info;
     VkEvent event;
@@ -3895,7 +3895,7 @@
     ASSERT_VK_SUCCESS(err);
 
     struct thread_data_struct data;
-    data.cmdBuffer = cmdBuffer.GetBufferHandle();
+    data.commandBuffer = commandBuffer.GetBufferHandle();
     data.event = event;
     data.bailout = false;
     m_errorMonitor->SetBailout(&data.bailout);
@@ -3905,7 +3905,7 @@
     AddToCommandBuffer(&data);
 
     test_platform_thread_join(thread, NULL);
-    cmdBuffer.EndCommandBuffer();
+    commandBuffer.EndCommandBuffer();
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an err from using one VkCommandBufferObj in two threads";
@@ -4053,7 +4053,7 @@
 
     VkDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendDummy();
-    descriptorSet.CreateVKDescriptorSet(m_cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     m_errorMonitor->ClearState();
     pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
@@ -4102,7 +4102,7 @@
 
     VkDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendDummy();
-    descriptorSet.CreateVKDescriptorSet(m_cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     m_errorMonitor->ClearState();
     pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
@@ -4153,7 +4153,7 @@
 
     VkDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendDummy();
-    descriptorSet.CreateVKDescriptorSet(m_cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     m_errorMonitor->ClearState();
     pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
@@ -4211,7 +4211,7 @@
 
     VkDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendDummy();
-    descriptorSet.CreateVKDescriptorSet(m_cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     m_errorMonitor->ClearState();
     pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
@@ -4260,7 +4260,7 @@
 
     VkDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendDummy();
-    descriptorSet.CreateVKDescriptorSet(m_cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     m_errorMonitor->ClearState();
     pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
@@ -4319,7 +4319,7 @@
 
     VkDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendDummy();
-    descriptorSet.CreateVKDescriptorSet(m_cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     m_errorMonitor->ClearState();
     pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
@@ -4379,7 +4379,7 @@
 
     VkDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendDummy();
-    descriptorSet.CreateVKDescriptorSet(m_cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     m_errorMonitor->ClearState();
     pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
@@ -4430,7 +4430,7 @@
 
     VkDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendDummy();
-    descriptorSet.CreateVKDescriptorSet(m_cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     m_errorMonitor->ClearState();
     pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
@@ -4483,7 +4483,7 @@
 
     VkDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendDummy();
-    descriptorSet.CreateVKDescriptorSet(m_cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     m_errorMonitor->ClearState();
     pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
@@ -4533,7 +4533,7 @@
 
     VkDescriptorSetObj descriptorSet(m_device);
     descriptorSet.AppendDummy();
-    descriptorSet.CreateVKDescriptorSet(m_cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     m_errorMonitor->ClearState();
     pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
@@ -4586,7 +4586,7 @@
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
     VkDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.CreateVKDescriptorSet(m_cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(m_commandBuffer);
 
     pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
 
@@ -4707,14 +4707,14 @@
 
     BeginCommandBuffer();
     // Introduce failure by using offset that is not multiple of 4
-    m_cmdBuffer->UpdateBuffer(buffer.handle(), 1, 4, updateData);
+    m_commandBuffer->UpdateBuffer(buffer.handle(), 1, 4, updateData);
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an err after calling UpdateBuffer with bad offset";
-    if (!strstr(msgString.c_str(),"destOffset, is not a multiple of 4")) {
-        FAIL() << "Error received was not 'vkCmdUpdateBuffer parameter, VkDeviceSize destOffset, is not a multiple of 4'";
+    if (!strstr(msgString.c_str(),"dstOffset, is not a multiple of 4")) {
+        FAIL() << "Error received was not 'vkCmdUpdateBuffer parameter, VkDeviceSize dstOffset, is not a multiple of 4'";
     }
     // Introduce failure by using size that is not multiple of 4
-    m_cmdBuffer->UpdateBuffer(buffer.handle(), 0, 6, updateData);
+    m_commandBuffer->UpdateBuffer(buffer.handle(), 0, 6, updateData);
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an err after calling UpdateBuffer with bad size";
     if (!strstr(msgString.c_str(),"dataSize, is not a multiple of 4")) {
@@ -4736,14 +4736,14 @@
 
     BeginCommandBuffer();
     // Introduce failure by using offset that is not multiple of 4
-    m_cmdBuffer->FillBuffer(buffer.handle(), 1, 4, 0x11111111);
+    m_commandBuffer->FillBuffer(buffer.handle(), 1, 4, 0x11111111);
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an err after calling FillBuffer with bad offset";
-    if (!strstr(msgString.c_str(),"destOffset, is not a multiple of 4")) {
-        FAIL() << "Error received was not 'vkCmdFillBuffer parameter, VkDeviceSize destOffset, is not a multiple of 4'";
+    if (!strstr(msgString.c_str(),"dstOffset, is not a multiple of 4")) {
+        FAIL() << "Error received was not 'vkCmdFillBuffer parameter, VkDeviceSize dstOffset, is not a multiple of 4'";
     }
     // Introduce failure by using size that is not multiple of 4
-    m_cmdBuffer->FillBuffer(buffer.handle(), 0, 6, 0x11111111);
+    m_commandBuffer->FillBuffer(buffer.handle(), 0, 6, 0x11111111);
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an err after calling FillBuffer with bad size";
     if (!strstr(msgString.c_str(),"size, is not a multiple of 4")) {
@@ -4794,9 +4794,9 @@
         image_view_create_info.image = image;
         image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
         image_view_create_info.format = tex_format;
-        image_view_create_info.subresourceRange.numLayers = 1;
+        image_view_create_info.subresourceRange.layerCount = 1;
         image_view_create_info.subresourceRange.baseMipLevel = 10; // cause an error
-        image_view_create_info.subresourceRange.numLevels = 1;
+        image_view_create_info.subresourceRange.levelCount = 1;
         image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 
     VkImageView view;
@@ -4848,7 +4848,7 @@
         image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
         image_view_create_info.format = tex_format;
         image_view_create_info.subresourceRange.baseMipLevel = 0;
-        image_view_create_info.subresourceRange.numLevels = 1;
+        image_view_create_info.subresourceRange.levelCount = 1;
         // Cause an error by setting an invalid image aspect
         image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT;
 
@@ -4874,7 +4874,7 @@
 
     // Create two images of different types and try to copy between them
     VkImage               srcImage;
-    VkImage               destImage;
+    VkImage               dstImage;
     VkDeviceMemory        srcMem;
     VkDeviceMemory        destMem;
     VkMemoryRequirements  memReqs;
@@ -4891,20 +4891,20 @@
         image_create_info.arrayLayers = 1;
         image_create_info.samples = 1;
         image_create_info.tiling = VK_IMAGE_TILING_LINEAR;
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
         image_create_info.flags = 0;
 
     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
     ASSERT_VK_SUCCESS(err);
 
         image_create_info.imageType = VK_IMAGE_TYPE_1D;
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
-    VkMemoryAllocInfo memAlloc = {};
+    VkMemoryAllocateInfo memAlloc = {};
         memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
         memAlloc.pNext = NULL;
         memAlloc.allocationSize = 0;
@@ -4914,19 +4914,19 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
-    vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
+    vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_VK_SUCCESS(err);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
     ASSERT_VK_SUCCESS(err);
-    err = vkBindImageMemory(m_device->device(), destImage, destMem, 0);
+    err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
     ASSERT_VK_SUCCESS(err);
 
     BeginCommandBuffer();
@@ -4934,21 +4934,21 @@
     copyRegion.srcSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
     copyRegion.srcSubresource.mipLevel = 0;
     copyRegion.srcSubresource.baseArrayLayer = 0;
-    copyRegion.srcSubresource.numLayers = 0;
+    copyRegion.srcSubresource.layerCount = 0;
     copyRegion.srcOffset.x = 0;
     copyRegion.srcOffset.y = 0;
     copyRegion.srcOffset.z = 0;
-    copyRegion.destSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-    copyRegion.destSubresource.mipLevel = 0;
-    copyRegion.destSubresource.baseArrayLayer = 0;
-    copyRegion.destSubresource.numLayers = 0;
-    copyRegion.destOffset.x = 0;
-    copyRegion.destOffset.y = 0;
-    copyRegion.destOffset.z = 0;
+    copyRegion.dstSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
+    copyRegion.dstSubresource.mipLevel = 0;
+    copyRegion.dstSubresource.baseArrayLayer = 0;
+    copyRegion.dstSubresource.layerCount = 0;
+    copyRegion.dstOffset.x = 0;
+    copyRegion.dstOffset.y = 0;
+    copyRegion.dstOffset.z = 0;
     copyRegion.extent.width = 1;
     copyRegion.extent.height = 1;
     copyRegion.extent.depth = 1;
-    m_cmdBuffer->CopyImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, destImage, VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
+    m_commandBuffer->CopyImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, dstImage, VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
     EndCommandBuffer();
 
     msgFlags = m_errorMonitor->GetState(&msgString);
@@ -4958,7 +4958,7 @@
     }
 
     vkDestroyImage(m_device->device(), srcImage, NULL);
-    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkDestroyImage(m_device->device(), dstImage, NULL);
     vkFreeMemory(m_device->device(), srcMem, NULL);
     vkFreeMemory(m_device->device(), destMem, NULL);
 }
@@ -4980,7 +4980,7 @@
 
     // Create two images of different types and try to copy between them
     VkImage               srcImage;
-    VkImage               destImage;
+    VkImage               dstImage;
     VkDeviceMemory        srcMem;
     VkDeviceMemory        destMem;
     VkMemoryRequirements  memReqs;
@@ -4997,20 +4997,20 @@
         image_create_info.arrayLayers = 1;
         image_create_info.samples = 1;
         image_create_info.tiling = VK_IMAGE_TILING_LINEAR;
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
         image_create_info.flags = 0;
 
     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
     ASSERT_VK_SUCCESS(err);
 
         image_create_info.imageType = VK_IMAGE_TYPE_1D;
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
-    VkMemoryAllocInfo memAlloc = {};
+    VkMemoryAllocateInfo memAlloc = {};
         memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
         memAlloc.pNext = NULL;
         memAlloc.allocationSize = 0;
@@ -5020,19 +5020,19 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
-    vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
+    vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
     ASSERT_VK_SUCCESS(err);
-    err = vkBindImageMemory(m_device->device(), destImage, destMem, 0);
+    err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
     ASSERT_VK_SUCCESS(err);
 
     BeginCommandBuffer();
@@ -5040,21 +5040,21 @@
     copyRegion.srcSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
     copyRegion.srcSubresource.mipLevel = 0;
     copyRegion.srcSubresource.baseArrayLayer = 0;
-    copyRegion.srcSubresource.numLayers = 0;
+    copyRegion.srcSubresource.layerCount = 0;
     copyRegion.srcOffset.x = 0;
     copyRegion.srcOffset.y = 0;
     copyRegion.srcOffset.z = 0;
-    copyRegion.destSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-    copyRegion.destSubresource.mipLevel = 0;
-    copyRegion.destSubresource.baseArrayLayer = 0;
-    copyRegion.destSubresource.numLayers = 0;
-    copyRegion.destOffset.x = 0;
-    copyRegion.destOffset.y = 0;
-    copyRegion.destOffset.z = 0;
+    copyRegion.dstSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
+    copyRegion.dstSubresource.mipLevel = 0;
+    copyRegion.dstSubresource.baseArrayLayer = 0;
+    copyRegion.dstSubresource.layerCount = 0;
+    copyRegion.dstOffset.x = 0;
+    copyRegion.dstOffset.y = 0;
+    copyRegion.dstOffset.z = 0;
     copyRegion.extent.width = 1;
     copyRegion.extent.height = 1;
     copyRegion.extent.depth = 1;
-    m_cmdBuffer->CopyImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, destImage, VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
+    m_commandBuffer->CopyImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, dstImage, VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
     EndCommandBuffer();
 
     msgFlags = m_errorMonitor->GetState(&msgString);
@@ -5064,7 +5064,7 @@
     }
 
     vkDestroyImage(m_device->device(), srcImage, NULL);
-    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkDestroyImage(m_device->device(), dstImage, NULL);
     vkFreeMemory(m_device->device(), srcMem, NULL);
     vkFreeMemory(m_device->device(), destMem, NULL);
 }
@@ -5081,7 +5081,7 @@
 
     // Create two images of sample count 1 and try to Resolve between them
     VkImage               srcImage;
-    VkImage               destImage;
+    VkImage               dstImage;
     VkDeviceMemory        srcMem;
     VkDeviceMemory        destMem;
     VkMemoryRequirements  memReqs;
@@ -5098,20 +5098,20 @@
         image_create_info.arrayLayers = 1;
         image_create_info.samples = 1;
         image_create_info.tiling = VK_IMAGE_TILING_LINEAR;
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
         image_create_info.flags = 0;
 
     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
     ASSERT_VK_SUCCESS(err);
 
         image_create_info.imageType = VK_IMAGE_TYPE_1D;
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
-    VkMemoryAllocInfo memAlloc = {};
+    VkMemoryAllocateInfo memAlloc = {};
         memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
         memAlloc.pNext = NULL;
         memAlloc.allocationSize = 0;
@@ -5121,19 +5121,19 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
-    vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
+    vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
     ASSERT_VK_SUCCESS(err);
-    err = vkBindImageMemory(m_device->device(), destImage, destMem, 0);
+    err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
     ASSERT_VK_SUCCESS(err);
 
     BeginCommandBuffer();
@@ -5144,21 +5144,21 @@
     resolveRegion.srcSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
     resolveRegion.srcSubresource.mipLevel = 0;
     resolveRegion.srcSubresource.baseArrayLayer = 0;
-    resolveRegion.srcSubresource.numLayers = 0;
+    resolveRegion.srcSubresource.layerCount = 0;
     resolveRegion.srcOffset.x = 0;
     resolveRegion.srcOffset.y = 0;
     resolveRegion.srcOffset.z = 0;
-    resolveRegion.destSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-    resolveRegion.destSubresource.mipLevel = 0;
-    resolveRegion.destSubresource.baseArrayLayer = 0;
-    resolveRegion.destSubresource.numLayers = 0;
-    resolveRegion.destOffset.x = 0;
-    resolveRegion.destOffset.y = 0;
-    resolveRegion.destOffset.z = 0;
+    resolveRegion.dstSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
+    resolveRegion.dstSubresource.mipLevel = 0;
+    resolveRegion.dstSubresource.baseArrayLayer = 0;
+    resolveRegion.dstSubresource.layerCount = 0;
+    resolveRegion.dstOffset.x = 0;
+    resolveRegion.dstOffset.y = 0;
+    resolveRegion.dstOffset.z = 0;
     resolveRegion.extent.width = 1;
     resolveRegion.extent.height = 1;
     resolveRegion.extent.depth = 1;
-    m_cmdBuffer->ResolveImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, destImage, VK_IMAGE_LAYOUT_GENERAL, 1, &resolveRegion);
+    m_commandBuffer->ResolveImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, dstImage, VK_IMAGE_LAYOUT_GENERAL, 1, &resolveRegion);
     EndCommandBuffer();
 
     msgFlags = m_errorMonitor->GetState(&msgString);
@@ -5168,7 +5168,7 @@
     }
 
     vkDestroyImage(m_device->device(), srcImage, NULL);
-    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkDestroyImage(m_device->device(), dstImage, NULL);
     vkFreeMemory(m_device->device(), srcMem, NULL);
     vkFreeMemory(m_device->device(), destMem, NULL);
 }
@@ -5185,7 +5185,7 @@
 
     // Create two images of sample count 2 and try to Resolve between them
     VkImage               srcImage;
-    VkImage               destImage;
+    VkImage               dstImage;
     VkDeviceMemory        srcMem;
     VkDeviceMemory        destMem;
     VkMemoryRequirements  memReqs;
@@ -5203,7 +5203,7 @@
         image_create_info.samples = 2;
         image_create_info.tiling = VK_IMAGE_TILING_LINEAR;
         // Note: Some implementations expect color attachment usage for any multisample surface
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         image_create_info.flags = 0;
 
     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
@@ -5211,13 +5211,13 @@
 
         image_create_info.imageType = VK_IMAGE_TYPE_1D;
         // Note: Some implementations expect color attachment usage for any multisample surface
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
-    VkMemoryAllocInfo memAlloc = {};
+    VkMemoryAllocateInfo memAlloc = {};
         memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
         memAlloc.pNext = NULL;
         memAlloc.allocationSize = 0;
@@ -5227,19 +5227,19 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
-    vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
+    vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
     ASSERT_VK_SUCCESS(err);
-    err = vkBindImageMemory(m_device->device(), destImage, destMem, 0);
+    err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
     ASSERT_VK_SUCCESS(err);
 
     BeginCommandBuffer();
@@ -5250,21 +5250,21 @@
     resolveRegion.srcSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
     resolveRegion.srcSubresource.mipLevel = 0;
     resolveRegion.srcSubresource.baseArrayLayer = 0;
-    resolveRegion.srcSubresource.numLayers = 0;
+    resolveRegion.srcSubresource.layerCount = 0;
     resolveRegion.srcOffset.x = 0;
     resolveRegion.srcOffset.y = 0;
     resolveRegion.srcOffset.z = 0;
-    resolveRegion.destSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-    resolveRegion.destSubresource.mipLevel = 0;
-    resolveRegion.destSubresource.baseArrayLayer = 0;
-    resolveRegion.destSubresource.numLayers = 0;
-    resolveRegion.destOffset.x = 0;
-    resolveRegion.destOffset.y = 0;
-    resolveRegion.destOffset.z = 0;
+    resolveRegion.dstSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
+    resolveRegion.dstSubresource.mipLevel = 0;
+    resolveRegion.dstSubresource.baseArrayLayer = 0;
+    resolveRegion.dstSubresource.layerCount = 0;
+    resolveRegion.dstOffset.x = 0;
+    resolveRegion.dstOffset.y = 0;
+    resolveRegion.dstOffset.z = 0;
     resolveRegion.extent.width = 1;
     resolveRegion.extent.height = 1;
     resolveRegion.extent.depth = 1;
-    m_cmdBuffer->ResolveImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, destImage, VK_IMAGE_LAYOUT_GENERAL, 1, &resolveRegion);
+    m_commandBuffer->ResolveImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, dstImage, VK_IMAGE_LAYOUT_GENERAL, 1, &resolveRegion);
     EndCommandBuffer();
 
     msgFlags = m_errorMonitor->GetState(&msgString);
@@ -5274,7 +5274,7 @@
     }
 
     vkDestroyImage(m_device->device(), srcImage, NULL);
-    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkDestroyImage(m_device->device(), dstImage, NULL);
     vkFreeMemory(m_device->device(), srcMem, NULL);
     vkFreeMemory(m_device->device(), destMem, NULL);
 }
@@ -5291,7 +5291,7 @@
 
     // Create two images of different types and try to copy between them
     VkImage               srcImage;
-    VkImage               destImage;
+    VkImage               dstImage;
     VkDeviceMemory        srcMem;
     VkDeviceMemory        destMem;
     VkMemoryRequirements  memReqs;
@@ -5309,7 +5309,7 @@
         image_create_info.samples = 2;
         image_create_info.tiling = VK_IMAGE_TILING_LINEAR;
         // Note: Some implementations expect color attachment usage for any multisample surface
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         image_create_info.flags = 0;
 
     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
@@ -5318,14 +5318,14 @@
         // Set format to something other than source image
         image_create_info.format = VK_FORMAT_R32_SFLOAT;
         // Note: Some implementations expect color attachment usage for any multisample surface
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         image_create_info.samples = 1;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
-    VkMemoryAllocInfo memAlloc = {};
+    VkMemoryAllocateInfo memAlloc = {};
         memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
         memAlloc.pNext = NULL;
         memAlloc.allocationSize = 0;
@@ -5335,19 +5335,19 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
-    vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
+    vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
     ASSERT_VK_SUCCESS(err);
-    err = vkBindImageMemory(m_device->device(), destImage, destMem, 0);
+    err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
     ASSERT_VK_SUCCESS(err);
 
     BeginCommandBuffer();
@@ -5358,21 +5358,21 @@
     resolveRegion.srcSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
     resolveRegion.srcSubresource.mipLevel = 0;
     resolveRegion.srcSubresource.baseArrayLayer = 0;
-    resolveRegion.srcSubresource.numLayers = 0;
+    resolveRegion.srcSubresource.layerCount = 0;
     resolveRegion.srcOffset.x = 0;
     resolveRegion.srcOffset.y = 0;
     resolveRegion.srcOffset.z = 0;
-    resolveRegion.destSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-    resolveRegion.destSubresource.mipLevel = 0;
-    resolveRegion.destSubresource.baseArrayLayer = 0;
-    resolveRegion.destSubresource.numLayers = 0;
-    resolveRegion.destOffset.x = 0;
-    resolveRegion.destOffset.y = 0;
-    resolveRegion.destOffset.z = 0;
+    resolveRegion.dstSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
+    resolveRegion.dstSubresource.mipLevel = 0;
+    resolveRegion.dstSubresource.baseArrayLayer = 0;
+    resolveRegion.dstSubresource.layerCount = 0;
+    resolveRegion.dstOffset.x = 0;
+    resolveRegion.dstOffset.y = 0;
+    resolveRegion.dstOffset.z = 0;
     resolveRegion.extent.width = 1;
     resolveRegion.extent.height = 1;
     resolveRegion.extent.depth = 1;
-    m_cmdBuffer->ResolveImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, destImage, VK_IMAGE_LAYOUT_GENERAL, 1, &resolveRegion);
+    m_commandBuffer->ResolveImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, dstImage, VK_IMAGE_LAYOUT_GENERAL, 1, &resolveRegion);
     EndCommandBuffer();
 
     msgFlags = m_errorMonitor->GetState(&msgString);
@@ -5382,7 +5382,7 @@
     }
 
     vkDestroyImage(m_device->device(), srcImage, NULL);
-    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkDestroyImage(m_device->device(), dstImage, NULL);
     vkFreeMemory(m_device->device(), srcMem, NULL);
     vkFreeMemory(m_device->device(), destMem, NULL);
 }
@@ -5399,7 +5399,7 @@
 
     // Create two images of different types and try to copy between them
     VkImage               srcImage;
-    VkImage               destImage;
+    VkImage               dstImage;
     VkDeviceMemory        srcMem;
     VkDeviceMemory        destMem;
     VkMemoryRequirements  memReqs;
@@ -5417,7 +5417,7 @@
         image_create_info.samples = 2;
         image_create_info.tiling = VK_IMAGE_TILING_LINEAR;
         // Note: Some implementations expect color attachment usage for any multisample surface
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         image_create_info.flags = 0;
 
     err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
@@ -5425,14 +5425,14 @@
 
         image_create_info.imageType = VK_IMAGE_TYPE_1D;
         // Note: Some implementations expect color attachment usage for any multisample surface
-        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+        image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         image_create_info.samples = 1;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &dstImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
-    VkMemoryAllocInfo memAlloc = {};
+    VkMemoryAllocateInfo memAlloc = {};
         memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
         memAlloc.pNext = NULL;
         memAlloc.allocationSize = 0;
@@ -5442,19 +5442,19 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
-    vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
+    vkGetImageMemoryRequirements(m_device->device(), dstImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
+    err = vkAllocateMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
     ASSERT_VK_SUCCESS(err);
-    err = vkBindImageMemory(m_device->device(), destImage, destMem, 0);
+    err = vkBindImageMemory(m_device->device(), dstImage, destMem, 0);
     ASSERT_VK_SUCCESS(err);
 
     BeginCommandBuffer();
@@ -5465,21 +5465,21 @@
     resolveRegion.srcSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
     resolveRegion.srcSubresource.mipLevel = 0;
     resolveRegion.srcSubresource.baseArrayLayer = 0;
-    resolveRegion.srcSubresource.numLayers = 0;
+    resolveRegion.srcSubresource.layerCount = 0;
     resolveRegion.srcOffset.x = 0;
     resolveRegion.srcOffset.y = 0;
     resolveRegion.srcOffset.z = 0;
-    resolveRegion.destSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-    resolveRegion.destSubresource.mipLevel = 0;
-    resolveRegion.destSubresource.baseArrayLayer = 0;
-    resolveRegion.destSubresource.numLayers = 0;
-    resolveRegion.destOffset.x = 0;
-    resolveRegion.destOffset.y = 0;
-    resolveRegion.destOffset.z = 0;
+    resolveRegion.dstSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
+    resolveRegion.dstSubresource.mipLevel = 0;
+    resolveRegion.dstSubresource.baseArrayLayer = 0;
+    resolveRegion.dstSubresource.layerCount = 0;
+    resolveRegion.dstOffset.x = 0;
+    resolveRegion.dstOffset.y = 0;
+    resolveRegion.dstOffset.z = 0;
     resolveRegion.extent.width = 1;
     resolveRegion.extent.height = 1;
     resolveRegion.extent.depth = 1;
-    m_cmdBuffer->ResolveImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, destImage, VK_IMAGE_LAYOUT_GENERAL, 1, &resolveRegion);
+    m_commandBuffer->ResolveImage(srcImage, VK_IMAGE_LAYOUT_GENERAL, dstImage, VK_IMAGE_LAYOUT_GENERAL, 1, &resolveRegion);
     EndCommandBuffer();
 
     msgFlags = m_errorMonitor->GetState(&msgString);
@@ -5489,7 +5489,7 @@
     }
 
     vkDestroyImage(m_device->device(), srcImage, NULL);
-    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkDestroyImage(m_device->device(), dstImage, NULL);
     vkFreeMemory(m_device->device(), srcMem, NULL);
     vkFreeMemory(m_device->device(), destMem, NULL);
 }
@@ -5537,12 +5537,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = 1;
     alloc_info.descriptorPool = ds_pool;
     alloc_info.pSetLayouts = &ds_layout;
-    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
+    err = vkAllocateDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkImage               image_bad;
@@ -5582,8 +5582,8 @@
         image_view_create_info.format = tex_format_bad;
         image_view_create_info.subresourceRange.baseArrayLayer = 0;
         image_view_create_info.subresourceRange.baseMipLevel = 0;
-        image_view_create_info.subresourceRange.numLayers = 1;
-        image_view_create_info.subresourceRange.numLevels = 1;
+        image_view_create_info.subresourceRange.layerCount = 1;
+        image_view_create_info.subresourceRange.levelCount = 1;
         image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 
     VkImageView view;
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index 9576e69..b9de073 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -266,32 +266,32 @@
 public:
 
     void RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model,
-                                 VkConstantBufferObj *constantBuffer, VkCommandBufferObj *cmdBuffer);
-    void GenericDrawPreparation(VkCommandBufferObj *cmdBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet);
+                                 VkConstantBufferObj *constantBuffer, VkCommandBufferObj *commandBuffer);
+    void GenericDrawPreparation(VkCommandBufferObj *commandBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet);
     void GenericDrawPreparation(VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet)
-             { GenericDrawPreparation(m_cmdBuffer, pipelineobj, descriptorSet); }
+             { GenericDrawPreparation(m_commandBuffer, pipelineobj, descriptorSet); }
     void InitDepthStencil();
     void VKTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate);
 
-    VkResult BeginCommandBuffer(VkCommandBufferObj &cmdBuffer);
-    VkResult BeginCommandBuffer(VkCommandBufferObj &cmdBuffer, VkCmdBufferBeginInfo *beginInfo);
-    VkResult EndCommandBuffer(VkCommandBufferObj &cmdBuffer);
+    VkResult BeginCommandBuffer(VkCommandBufferObj &commandBuffer);
+    VkResult BeginCommandBuffer(VkCommandBufferObj &commandBuffer, VkCommandBufferBeginInfo *beginInfo);
+    VkResult EndCommandBuffer(VkCommandBufferObj &commandBuffer);
     /* Convenience functions that use built-in command buffer */
-    VkResult BeginCommandBuffer() { return BeginCommandBuffer(*m_cmdBuffer); }
-    VkResult BeginCommandBuffer(VkCmdBufferBeginInfo *beginInfo) { return BeginCommandBuffer(*m_cmdBuffer, beginInfo); }
-    VkResult EndCommandBuffer() { return EndCommandBuffer(*m_cmdBuffer); }
+    VkResult BeginCommandBuffer() { return BeginCommandBuffer(*m_commandBuffer); }
+    VkResult BeginCommandBuffer(VkCommandBufferBeginInfo *beginInfo) { return BeginCommandBuffer(*m_commandBuffer, beginInfo); }
+    VkResult EndCommandBuffer() { return EndCommandBuffer(*m_commandBuffer); }
     void Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
-        { m_cmdBuffer->Draw(vertexCount, instanceCount, firstVertex, firstInstance); }
+        { m_commandBuffer->Draw(vertexCount, instanceCount, firstVertex, firstInstance); }
     void DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
-        { m_cmdBuffer->DrawIndexed(indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); }
-    void QueueCommandBuffer() { m_cmdBuffer->QueueCommandBuffer(); }
+        { m_commandBuffer->DrawIndexed(indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); }
+    void QueueCommandBuffer() { m_commandBuffer->QueueCommandBuffer(); }
     void RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model,
                                  VkConstantBufferObj *constantBuffer)
-        {RotateTriangleVSUniform(Projection, View, Model, constantBuffer, m_cmdBuffer); }
+        {RotateTriangleVSUniform(Projection, View, Model, constantBuffer, m_commandBuffer); }
     void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkDeviceSize offset, uint32_t binding)
-        { m_cmdBuffer->BindVertexBuffer(vertexBuffer, offset, binding); }
+        { m_commandBuffer->BindVertexBuffer(vertexBuffer, offset, binding); }
     void BindIndexBuffer(VkIndexBufferObj *indexBuffer, VkDeviceSize offset)
-        { m_cmdBuffer->BindIndexBuffer(indexBuffer, offset); }
+        { m_commandBuffer->BindIndexBuffer(indexBuffer, offset); }
 
 
 
@@ -307,8 +307,8 @@
 
         this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
         this->app_info.pNext = NULL;
-        this->app_info.pAppName = "render_tests";
-        this->app_info.appVersion = 1;
+        this->app_info.pApplicationName = "render_tests";
+        this->app_info.applicationVersion = 1;
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
         this->app_info.apiVersion = VK_API_VERSION;
@@ -322,77 +322,77 @@
     }
 };
 
-VkResult VkRenderTest::BeginCommandBuffer(VkCommandBufferObj &cmdBuffer)
+VkResult VkRenderTest::BeginCommandBuffer(VkCommandBufferObj &commandBuffer)
 {
     VkResult result;
 
-    result = cmdBuffer.BeginCommandBuffer();
+    result = commandBuffer.BeginCommandBuffer();
 
     /*
      * For render test all drawing happens in a single render pass
      * on a single command buffer.
      */
     if (VK_SUCCESS == result && renderPass()) {
-        cmdBuffer.BeginRenderPass(renderPassBeginInfo());
+        commandBuffer.BeginRenderPass(renderPassBeginInfo());
     }
 
     return result;
 }
 
-VkResult VkRenderTest::BeginCommandBuffer(VkCommandBufferObj &cmdBuffer, VkCmdBufferBeginInfo *beginInfo)
+VkResult VkRenderTest::BeginCommandBuffer(VkCommandBufferObj &commandBuffer, VkCommandBufferBeginInfo *beginInfo)
 {
     VkResult result;
 
-    result = cmdBuffer.BeginCommandBuffer(beginInfo);
+    result = commandBuffer.BeginCommandBuffer(beginInfo);
 
     /*
      * For render test all drawing happens in a single render pass
      * on a single command buffer.
      */
     if (VK_SUCCESS == result && renderPass()) {
-        cmdBuffer.BeginRenderPass(renderPassBeginInfo());
+        commandBuffer.BeginRenderPass(renderPassBeginInfo());
     }
 
     return result;
 }
 
-VkResult VkRenderTest::EndCommandBuffer(VkCommandBufferObj &cmdBuffer)
+VkResult VkRenderTest::EndCommandBuffer(VkCommandBufferObj &commandBuffer)
 {
     VkResult result;
 
     if (renderPass()) {
-        cmdBuffer.EndRenderPass();
+        commandBuffer.EndRenderPass();
     }
 
-    result = cmdBuffer.EndCommandBuffer();
+    result = commandBuffer.EndCommandBuffer();
 
     return result;
 }
 
 
-void VkRenderTest::GenericDrawPreparation(VkCommandBufferObj *cmdBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet)
+void VkRenderTest::GenericDrawPreparation(VkCommandBufferObj *commandBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet)
 {
     if (!m_clear_via_load_op) {
         if (m_depthStencil->Initialized()) {
-            cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, m_depthStencil);
+            commandBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, m_depthStencil);
         } else {
-            cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
+            commandBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
         }
     }
 
-    cmdBuffer->PrepareAttachments();
-    cmdBuffer->SetViewport(m_viewports.size(), m_viewports.data());
-    cmdBuffer->SetScissor(m_scissors.size(), m_scissors.data());
+    commandBuffer->PrepareAttachments();
+    commandBuffer->SetViewport(m_viewports.size(), m_viewports.data());
+    commandBuffer->SetScissor(m_scissors.size(), m_scissors.data());
 
-    descriptorSet.CreateVKDescriptorSet(cmdBuffer);
+    descriptorSet.CreateVKDescriptorSet(commandBuffer);
     VkResult err = pipelineobj.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
     ASSERT_VK_SUCCESS(err);
-    cmdBuffer->BindPipeline(pipelineobj);
-    cmdBuffer->BindDescriptorSet(descriptorSet);
+    commandBuffer->BindPipeline(pipelineobj);
+    commandBuffer->BindDescriptorSet(descriptorSet);
 }
 
 void VkRenderTest::RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model,
-                                            VkConstantBufferObj *constantBuffer, VkCommandBufferObj *cmdBuffer)
+                                            VkConstantBufferObj *constantBuffer, VkCommandBufferObj *commandBuffer)
 {
     int i;
     glm::mat4 MVP;
@@ -410,7 +410,7 @@
         constantBuffer->memory().unmap();
 
         // submit the command buffer to the universal queue
-        cmdBuffer->QueueCommandBuffer();
+        commandBuffer->QueueCommandBuffer();
 
         err = vkQueueWaitIdle( m_device->m_queue );
         ASSERT_VK_SUCCESS( err );
@@ -503,9 +503,9 @@
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
-    VkCmdBufferBeginInfo cbBeginInfo;
-    memset(&cbBeginInfo, 0, sizeof(VkCmdBufferBeginInfo));
-    cbBeginInfo.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    VkCommandBufferBeginInfo cbBeginInfo;
+    memset(&cbBeginInfo, 0, sizeof(VkCommandBufferBeginInfo));
+    cbBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     cbBeginInfo.flags = 0;
     ASSERT_VK_SUCCESS(BeginCommandBuffer(&cbBeginInfo));
 
@@ -1406,9 +1406,9 @@
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
-    VkCmdBufferBeginInfo cbBeginInfo;
-    memset(&cbBeginInfo, 0, sizeof(VkCmdBufferBeginInfo));
-    cbBeginInfo.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    VkCommandBufferBeginInfo cbBeginInfo;
+    memset(&cbBeginInfo, 0, sizeof(VkCommandBufferBeginInfo));
+    cbBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     cbBeginInfo.flags = 0;
     ASSERT_VK_SUCCESS(BeginCommandBuffer(&cbBeginInfo));
 
@@ -1852,7 +1852,7 @@
     VkPipelineDepthStencilStateCreateInfo ds_state;
     ds_state.depthTestEnable = VK_TRUE;
     ds_state.depthWriteEnable = VK_TRUE;
-    ds_state.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
+    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;
@@ -2763,7 +2763,7 @@
     VkPipelineDepthStencilStateCreateInfo ds_state;
     ds_state.depthTestEnable = VK_TRUE;
     ds_state.depthWriteEnable = VK_TRUE;
-    ds_state.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
+    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;
@@ -2775,9 +2775,9 @@
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget(m_depthStencil->BindInfo()));
 
-    VkCmdBufferBeginInfo cbBeginInfo;
-    memset(&cbBeginInfo, 0, sizeof(VkCmdBufferBeginInfo));
-    cbBeginInfo.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    VkCommandBufferBeginInfo cbBeginInfo;
+    memset(&cbBeginInfo, 0, sizeof(VkCommandBufferBeginInfo));
+    cbBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     cbBeginInfo.flags = 0;
     ASSERT_VK_SUCCESS(BeginCommandBuffer(&cbBeginInfo));
 
@@ -4137,7 +4137,7 @@
     color_attachment.clearValue.color.float32[3] = 0;
     color_attachment.colorAttachment = 0;
     VkClearRect clear_rect = { { { 0, 0 }, { (int)m_width, (int)m_height } } };
-    vkCmdClearAttachments(m_cmdBuffer->handle(), 1, &color_attachment,
+    vkCmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment,
                           1, &clear_rect);
 
     EndCommandBuffer();
diff --git a/tests/test_environment.cpp b/tests/test_environment.cpp
index bdd0808..1a5ca34 100644
--- a/tests/test_environment.cpp
+++ b/tests/test_environment.cpp
@@ -18,8 +18,8 @@
     default_dev_(0)
 {
     app_.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
-    app_.pAppName = "vk_testing";
-    app_.appVersion = 1;
+    app_.pApplicationName = "vk_testing";
+    app_.applicationVersion = 1;
     app_.pEngineName = "vk_testing";
     app_.engineVersion = 1;
     app_.apiVersion = VK_API_VERSION;
@@ -78,7 +78,7 @@
     for (uint32_t i = 0; i < instance_extension_names.size(); i++) {
         extFound = 0;
         for (uint32_t j = 0; j < instance_extensions.size(); j++) {
-            if (!strcmp(instance_extension_names[i], instance_extensions[j].extName)) {
+            if (!strcmp(instance_extension_names[i], instance_extensions[j].extensionName)) {
                 extFound = 1;
             }
         }
@@ -86,7 +86,7 @@
     }
     inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     inst_info.pNext = NULL;
-    inst_info.pAppInfo = &app_;
+    inst_info.pApplicationInfo = &app_;
     inst_info.enabledExtensionNameCount = instance_extension_names.size();
     inst_info.ppEnabledExtensionNames = (instance_extension_names.size()) ? &instance_extension_names[0] : NULL;
     inst_info.enabledLayerNameCount = 0;
@@ -106,7 +106,7 @@
     for (uint32_t i = 0; i < device_extension_names.size(); i++) {
         extFound = 0;
         for (uint32_t j = 0; j < device_extensions.size(); j++) {
-            if (!strcmp(device_extension_names[i], device_extensions[j].extName)) {
+            if (!strcmp(device_extension_names[i], device_extensions[j].extensionName)) {
                 extFound = 1;
             }
         }
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index a68b08c..34f5f2d 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -37,7 +37,7 @@
 }
 
 VkRenderFramework::VkRenderFramework() :
-    m_cmdBuffer(),
+    m_commandBuffer(),
     m_renderPass(VK_NULL_HANDLE),
     m_framebuffer(VK_NULL_HANDLE),
     m_width( 256.0 ),                   // default window width
@@ -97,7 +97,7 @@
 
     instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instInfo.pNext = NULL;
-    instInfo.pAppInfo = &app_info;
+    instInfo.pApplicationInfo = &app_info;
     instInfo.enabledLayerNameCount = instance_layer_names.size();
     instInfo.ppEnabledLayerNames = instance_layer_names.data();
     instInfo.enabledExtensionNameCount = instance_extension_names.size();
@@ -148,9 +148,9 @@
 
 void VkRenderFramework::ShutdownFramework()
 {
-    if (m_cmdBuffer)
-        delete m_cmdBuffer;
-    if (m_cmdPool) vkDestroyCommandPool(device(), m_cmdPool, NULL);
+    if (m_commandBuffer)
+        delete m_commandBuffer;
+    if (m_commandPool) vkDestroyCommandPool(device(), m_commandPool, NULL);
     if (m_framebuffer) vkDestroyFramebuffer(device(), m_framebuffer, NULL);
     if (m_renderPass) vkDestroyRenderPass(device(), m_renderPass, NULL);
 
@@ -218,15 +218,15 @@
     m_stencilWriteMask = 0xff;
     m_stencilReference = 0;
 
-    VkCmdPoolCreateInfo cmd_pool_info;
-    cmd_pool_info.sType = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO,
+    VkCommandPoolCreateInfo cmd_pool_info;
+    cmd_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
     cmd_pool_info.pNext = NULL,
     cmd_pool_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
     cmd_pool_info.flags = 0,
-    err = vkCreateCommandPool(device(), &cmd_pool_info, NULL, &m_cmdPool);
+    err = vkCreateCommandPool(device(), &cmd_pool_info, NULL, &m_commandPool);
     assert(!err);
 
-    m_cmdBuffer = new VkCommandBufferObj(m_device, m_cmdPool);
+    m_commandBuffer = new VkCommandBufferObj(m_device, m_commandPool);
 }
 
 void VkRenderFramework::InitViewport(float width, float height)
@@ -314,12 +314,12 @@
 
         if (props.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
             img->init((uint32_t)m_width, (uint32_t)m_height, m_render_target_fmt,
-            VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT,
+            VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
             VK_IMAGE_TILING_LINEAR);
         }
         else if (props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
             img->init((uint32_t)m_width, (uint32_t)m_height, m_render_target_fmt,
-            VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT,
+            VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
             VK_IMAGE_TILING_OPTIMAL);
         }
         else {
@@ -491,7 +491,7 @@
     return m_set->handle();
 }
 
-void VkDescriptorSetObj::CreateVKDescriptorSet(VkCommandBufferObj *cmdBuffer)
+void VkDescriptorSetObj::CreateVKDescriptorSet(VkCommandBufferObj *commandBuffer)
 {
     // create VkDescriptorPool
     VkDescriptorPoolCreateInfo pool = {};
@@ -536,7 +536,7 @@
     size_t imageSamplerCount = 0;
     for (std::vector<VkWriteDescriptorSet>::iterator it = m_writes.begin();
          it != m_writes.end(); it++) {
-        it->destSet = m_set->handle();
+        it->dstSet = m_set->handle();
         if (it->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
             it->pImageInfo = &m_imageSamplerDescriptors[imageSamplerCount++];
     }
@@ -614,12 +614,12 @@
     }
 
     switch (image_layout) {
-    case VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+    case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
         output_mask = VK_MEMORY_OUTPUT_TRANSFER_BIT;
         input_mask = VK_MEMORY_INPUT_SHADER_READ_BIT | VK_MEMORY_INPUT_TRANSFER_BIT;
         break;
 
-    case VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+    case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
         output_mask = VK_MEMORY_OUTPUT_TRANSFER_BIT;
         input_mask = VK_MEMORY_INPUT_SHADER_READ_BIT | VK_MEMORY_INPUT_TRANSFER_BIT;
         break;
@@ -648,12 +648,12 @@
         return;
     }
 
-    VkCmdPoolCreateInfo cmd_pool_info = {};
-        cmd_pool_info.sType = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO;
+    VkCommandPoolCreateInfo cmd_pool_info = {};
+        cmd_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
         cmd_pool_info.pNext = NULL;
         cmd_pool_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
         cmd_pool_info.flags = 0;
-    vk_testing::CmdPool pool(*m_device, cmd_pool_info);
+    vk_testing::CommandPool pool(*m_device, cmd_pool_info);
     VkCommandBufferObj cmd_buf(m_device, pool.handle());
 
     /* Build command buffer to set image layout in the driver */
@@ -739,12 +739,12 @@
     VkResult U_ASSERT_ONLY err;
     VkImageLayout src_image_layout, dest_image_layout;
 
-    VkCmdPoolCreateInfo cmd_pool_info = {};
-        cmd_pool_info.sType = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO;
+    VkCommandPoolCreateInfo cmd_pool_info = {};
+        cmd_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
         cmd_pool_info.pNext = NULL;
         cmd_pool_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
         cmd_pool_info.flags = 0;
-    vk_testing::CmdPool pool(*m_device, cmd_pool_info);
+    vk_testing::CommandPool pool(*m_device, cmd_pool_info);
     VkCommandBufferObj cmd_buf(m_device, pool.handle());
 
     /* Build command buffer to copy staging texture to usable texture */
@@ -753,10 +753,10 @@
 
     /* TODO: Can we determine image aspect from image object? */
     src_image_layout = src_image.layout();
-    src_image.SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL);
+    src_image.SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
 
     dest_image_layout = this->layout();
-    this->SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL);
+    this->SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
 
     VkImageCopy copy_region = {};
     copy_region.srcSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
@@ -765,12 +765,12 @@
     copy_region.srcOffset.x = 0;
     copy_region.srcOffset.y = 0;
     copy_region.srcOffset.z = 0;
-    copy_region.destSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-    copy_region.destSubresource.baseArrayLayer = 0;
-    copy_region.destSubresource.mipLevel = 0;
-    copy_region.destOffset.x = 0;
-    copy_region.destOffset.y = 0;
-    copy_region.destOffset.z = 0;
+    copy_region.dstSubresource.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
+    copy_region.dstSubresource.baseArrayLayer = 0;
+    copy_region.dstSubresource.mipLevel = 0;
+    copy_region.dstOffset.x = 0;
+    copy_region.dstOffset.y = 0;
+    copy_region.dstOffset.z = 0;
     copy_region.extent = src_image.extent();
 
     vkCmdCopyImage(cmd_buf.handle(),
@@ -801,7 +801,7 @@
     VkImageObj stagingImage(device);
     VkMemoryPropertyFlags reqs = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
 
-    stagingImage.init(16, 16, tex_format, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, VK_IMAGE_TILING_LINEAR, reqs);
+    stagingImage.init(16, 16, tex_format, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_LINEAR, reqs);
     VkSubresourceLayout layout = stagingImage.subresource_layout(subresource(VK_IMAGE_ASPECT_COLOR_BIT, 0, 0));
 
     if (colors == NULL)
@@ -821,12 +821,12 @@
     view.channels.a = VK_CHANNEL_SWIZZLE_A;
     view.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
     view.subresourceRange.baseMipLevel = 0;
-    view.subresourceRange.numLevels = 1;
+    view.subresourceRange.levelCount = 1;
     view.subresourceRange.baseArrayLayer = 0;
-    view.subresourceRange.numLayers = 1;
+    view.subresourceRange.layerCount = 1;
 
     /* create image */
-    init(16, 16, tex_format, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, VK_IMAGE_TILING_OPTIMAL);
+    init(16, 16, tex_format, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL);
 
     /* create image view */
     view.image = handle();
@@ -884,7 +884,7 @@
     // TODO: Should we call QueueRemoveMemReference for the constant buffer memory here?
     if (m_commandBuffer) {
         delete m_commandBuffer;
-        delete m_cmdPool;
+        delete m_commandPool;
     }
 }
 
@@ -915,9 +915,9 @@
     this->m_descriptorBufferInfo.range = allocationSize;
 }
 
-void VkConstantBufferObj::Bind(VkCmdBuffer cmdBuffer, VkDeviceSize offset, uint32_t binding)
+void VkConstantBufferObj::Bind(VkCommandBuffer commandBuffer, VkDeviceSize offset, uint32_t binding)
 {
-    vkCmdBindVertexBuffers(cmdBuffer, binding, 1, &handle(), &offset);
+    vkCmdBindVertexBuffers(commandBuffer, binding, 1, &handle(), &offset);
 }
 
 
@@ -944,13 +944,13 @@
     if (!m_commandBuffer)
     {
         m_fence.init(*m_device, vk_testing::Fence::create_info());
-        VkCmdPoolCreateInfo cmd_pool_info = {};
-            cmd_pool_info.sType = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO;
+        VkCommandPoolCreateInfo cmd_pool_info = {};
+            cmd_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
             cmd_pool_info.pNext = NULL;
             cmd_pool_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
             cmd_pool_info.flags = 0;
-        m_cmdPool = new vk_testing::CmdPool(*m_device, cmd_pool_info);
-        m_commandBuffer = new VkCommandBufferObj(m_device, m_cmdPool->handle());
+        m_commandPool = new vk_testing::CommandPool(*m_device, cmd_pool_info);
+        m_commandBuffer = new VkCommandBufferObj(m_device, m_commandPool->handle());
     }
     else
     {
@@ -958,8 +958,8 @@
     }
 
     // open the command buffer
-    VkCmdBufferBeginInfo cmd_buf_info = {};
-    cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    VkCommandBufferBeginInfo cmd_buf_info = {};
+    cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     cmd_buf_info.pNext = NULL;
     cmd_buf_info.flags = 0;
     cmd_buf_info.renderPass = VK_NULL_HANDLE;
@@ -984,7 +984,7 @@
     ASSERT_VK_SUCCESS(err);
 
     // submit the command buffer to the universal queue
-    VkCmdBuffer bufferArray[1];
+    VkCommandBuffer bufferArray[1];
     bufferArray[0] = m_commandBuffer->GetBufferHandle();
     VkSubmitInfo submit_info;
     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
@@ -1037,9 +1037,9 @@
     this->m_descriptorBufferInfo.range = allocationSize;
 }
 
-void VkIndexBufferObj::Bind(VkCmdBuffer cmdBuffer, VkDeviceSize offset)
+void VkIndexBufferObj::Bind(VkCommandBuffer commandBuffer, VkDeviceSize offset)
 {
-    vkCmdBindIndexBuffer(cmdBuffer, handle(), offset, m_indexType);
+    vkCmdBindIndexBuffer(commandBuffer, handle(), offset, m_indexType);
 }
 
 VkIndexType VkIndexBufferObj::GetIndexType()
@@ -1134,7 +1134,7 @@
     m_rs_state.rasterizerDiscardEnable = VK_FALSE;
     m_rs_state.fillMode = VK_FILL_MODE_SOLID;
     m_rs_state.cullMode = VK_CULL_MODE_BACK_BIT;
-    m_rs_state.frontFace = VK_FRONT_FACE_CW;
+    m_rs_state.frontFace = VK_FRONT_FACE_CLOCKWISE;
     m_rs_state.depthBiasEnable = VK_FALSE;
     m_rs_state.lineWidth = 1.0f;
     m_rs_state.depthBiasConstantFactor = 0.0f;
@@ -1155,7 +1155,7 @@
     m_ms_state.pSampleMask = NULL;
     m_ms_state.alphaToCoverageEnable = VK_FALSE;
     m_ms_state.alphaToOneEnable = VK_FALSE;
-    m_ms_state.rasterSamples = 1;
+    m_ms_state.rasterizationSamples = 1;
     m_ms_state.minSampleShading = 0;
     m_ms_state.sampleShadingEnable = 0;
 
@@ -1171,7 +1171,7 @@
     m_ds_state.depthTestEnable      = VK_FALSE;
     m_ds_state.depthWriteEnable     = VK_FALSE;
     m_ds_state.depthBoundsTestEnable = VK_FALSE;
-    m_ds_state.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
+    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;
@@ -1314,7 +1314,7 @@
     info.pTessellationState   = NULL;
     info.pInputAssemblyState  = &m_ia_state;
     info.pViewportState       = &m_vp_state;
-    info.pRasterState         = &m_rs_state;
+    info.pRasterizationState         = &m_rs_state;
     info.pMultisampleState    = &m_ms_state;
     info.pDepthStencilState   = &m_ds_state;
     info.pColorBlendState     = &m_cb_state;
@@ -1322,19 +1322,19 @@
     return init_try(*m_device, info);
 }
 
-VkCommandBufferObj::VkCommandBufferObj(VkDeviceObj *device, VkCmdPool pool)
+VkCommandBufferObj::VkCommandBufferObj(VkDeviceObj *device, VkCommandPool pool)
 {
     m_device = device;
 
-    init(*device, vk_testing::CmdBuffer::create_info(pool));
+    init(*device, vk_testing::CommandBuffer::create_info(pool));
 }
 
-VkCmdBuffer VkCommandBufferObj::GetBufferHandle()
+VkCommandBuffer VkCommandBufferObj::GetBufferHandle()
 {
     return handle();
 }
 
-VkResult VkCommandBufferObj::BeginCommandBuffer(VkCmdBufferBeginInfo *pInfo)
+VkResult VkCommandBufferObj::BeginCommandBuffer(VkCommandBufferBeginInfo *pInfo)
 {
     begin(pInfo);
     return VK_SUCCESS;
@@ -1352,9 +1352,9 @@
     return VK_SUCCESS;
 }
 
-void VkCommandBufferObj::PipelineBarrier(VkPipelineStageFlags src_stages,  VkPipelineStageFlags dest_stages, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers)
+void VkCommandBufferObj::PipelineBarrier(VkPipelineStageFlags src_stages,  VkPipelineStageFlags dest_stages, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers)
 {
-    vkCmdPipelineBarrier(handle(), src_stages, dest_stages, dependencyFlags, memBarrierCount, ppMemBarriers);
+    vkCmdPipelineBarrier(handle(), src_stages, dest_stages, dependencyFlags, memoryBarrierCount, ppMemoryBarriers);
 }
 
 void VkCommandBufferObj::ClearAllBuffers(VkClearColorValue clear_color, float depth_clear_color, uint32_t stencil_clear_color,
@@ -1373,9 +1373,9 @@
     VkImageSubresourceRange srRange = {};
     srRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
     srRange.baseMipLevel = 0;
-    srRange.numLevels = VK_REMAINING_MIP_LEVELS;
+    srRange.levelCount = VK_REMAINING_MIP_LEVELS;
     srRange.baseArrayLayer = 0;
-    srRange.numLayers = VK_REMAINING_ARRAY_LAYERS;
+    srRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
 
     VkImageMemoryBarrier memory_barrier = {};
     memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -1405,9 +1405,9 @@
         VkImageSubresourceRange dsRange = {};
         dsRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
         dsRange.baseMipLevel = 0;
-        dsRange.numLevels = VK_REMAINING_MIP_LEVELS;
+        dsRange.levelCount = VK_REMAINING_MIP_LEVELS;
         dsRange.baseArrayLayer = 0;
-        dsRange.numLayers = VK_REMAINING_ARRAY_LAYERS;
+        dsRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
 
         // prepare the depth buffer for clear
 
@@ -1441,19 +1441,19 @@
     vkCmdFillBuffer( handle(), buffer, offset, fill_size, data);
 }
 
-void VkCommandBufferObj::UpdateBuffer(VkBuffer buffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t *pData)
+void VkCommandBufferObj::UpdateBuffer(VkBuffer buffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t *pData)
 {
-    vkCmdUpdateBuffer(handle(), buffer, destOffset, dataSize, pData);
+    vkCmdUpdateBuffer(handle(), buffer, dstOffset, dataSize, pData);
 }
 
-void VkCommandBufferObj::CopyImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
+void VkCommandBufferObj::CopyImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
 {
-    vkCmdCopyImage(handle(), srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+    vkCmdCopyImage(handle(), srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-void VkCommandBufferObj::ResolveImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
+void VkCommandBufferObj::ResolveImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
 {
-    vkCmdResolveImage(handle(), srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+    vkCmdResolveImage(handle(), srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
 void VkCommandBufferObj::PrepareAttachments()
@@ -1479,9 +1479,9 @@
     VkImageSubresourceRange srRange = {};
     srRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
     srRange.baseMipLevel = 0;
-    srRange.numLevels = VK_REMAINING_MIP_LEVELS;
+    srRange.levelCount = VK_REMAINING_MIP_LEVELS;
     srRange.baseArrayLayer = 0;
-    srRange.numLayers = VK_REMAINING_ARRAY_LAYERS;
+    srRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
 
     VkImageMemoryBarrier memory_barrier = {};
     memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -1690,9 +1690,9 @@
     view_info.image = VK_NULL_HANDLE;
     view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
     view_info.subresourceRange.baseMipLevel = 0;
-    view_info.subresourceRange.numLevels = 1;
+    view_info.subresourceRange.levelCount = 1;
     view_info.subresourceRange.baseArrayLayer = 0;
-    view_info.subresourceRange.numLayers = 1;
+    view_info.subresourceRange.layerCount = 1;
     view_info.flags = 0;
     view_info.format = m_depth_stencil_fmt;
     view_info.image = handle();
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index 4415b9c..0e42cfd 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -106,8 +106,8 @@
     VkPhysicalDevice                    objs[16];
     uint32_t                            gpu_count;
     VkDeviceObj                        *m_device;
-    VkCmdPool                           m_cmdPool;
-    VkCommandBufferObj                 *m_cmdBuffer;
+    VkCommandPool                           m_commandPool;
+    VkCommandBufferObj                 *m_commandBuffer;
     VkRenderPass                        m_renderPass;
     VkFramebuffer                       m_framebuffer;
     std::vector<VkViewport>             m_viewports;
@@ -145,8 +145,8 @@
     virtual void SetUp() {
         this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
         this->app_info.pNext = NULL;
-        this->app_info.pAppName = "base";
-        this->app_info.appVersion = 1;
+        this->app_info.pApplicationName = "base";
+        this->app_info.applicationVersion = 1;
         this->app_info.pEngineName = "unittest";
         this->app_info.engineVersion = 1;
         this->app_info.apiVersion = VK_API_VERSION;
@@ -165,15 +165,15 @@
 class VkPipelineObj;
 class VkDescriptorSetObj;
 
-class VkCommandBufferObj : public vk_testing::CmdBuffer
+class VkCommandBufferObj : public vk_testing::CommandBuffer
 {
 public:
-    VkCommandBufferObj(VkDeviceObj *device, VkCmdPool pool);
-    VkCmdBuffer GetBufferHandle();
+    VkCommandBufferObj(VkDeviceObj *device, VkCommandPool pool);
+    VkCommandBuffer GetBufferHandle();
     VkResult BeginCommandBuffer();
-    VkResult BeginCommandBuffer(VkCmdBufferBeginInfo *pInfo);
+    VkResult BeginCommandBuffer(VkCommandBufferBeginInfo *pInfo);
     VkResult EndCommandBuffer();
-    void PipelineBarrier(VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+    void PipelineBarrier(VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
     void AddRenderTarget(VkImageObj *renderTarget);
     void AddDepthStencil();
     void ClearAllBuffers(VkClearColorValue clear_color, float depth_clear_color, uint32_t stencil_clear_color, VkDepthStencilObj *depthStencilObj);
@@ -198,9 +198,9 @@
     void SetStencilReadMask(VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
     void SetStencilWriteMask(VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
     void SetStencilReference(VkStencilFaceFlags faceMask, uint32_t stencilReference);
-    void UpdateBuffer(VkBuffer buffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t *pData);
-    void CopyImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
-    void ResolveImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+    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);
 
 protected:
     VkDeviceObj                        *m_device;
@@ -231,7 +231,7 @@
             VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
             VK_MEMORY_INPUT_TRANSFER_BIT);
 
-    void Bind(VkCmdBuffer cmdBuffer, VkDeviceSize offset, uint32_t binding);
+    void Bind(VkCommandBuffer commandBuffer, VkDeviceSize offset, uint32_t binding);
 
     VkDescriptorBufferInfo              m_descriptorBufferInfo;
 
@@ -240,7 +240,7 @@
     vk_testing::BufferView              m_bufferView;
     int                                 m_numVertices;
     int                                 m_stride;
-    vk_testing::CmdPool                *m_cmdPool;
+    vk_testing::CommandPool                *m_commandPool;
     VkCommandBufferObj                 *m_commandBuffer;
     vk_testing::Fence                   m_fence;
 };
@@ -250,7 +250,7 @@
 public:
     VkIndexBufferObj(VkDeviceObj *device);
     void CreateAndInitBuffer(int numIndexes, VkIndexType dataFormat, const void* data);
-    void Bind(VkCmdBuffer cmdBuffer, VkDeviceSize offset);
+    void Bind(VkCommandBuffer commandBuffer, VkDeviceSize offset);
     VkIndexType GetIndexType();
 
 protected:
@@ -383,7 +383,7 @@
     int AppendDummy();
     int AppendBuffer(VkDescriptorType type, VkConstantBufferObj &constantBuffer);
     int AppendSamplerTexture(VkSamplerObj* sampler, VkTextureObj* texture);
-    void CreateVKDescriptorSet(VkCommandBufferObj *cmdBuffer);
+    void CreateVKDescriptorSet(VkCommandBufferObj *commandBuffer);
 
     VkDescriptorSet GetDescriptorSetHandle() const;
     VkPipelineLayout GetPipelineLayout() const;
@@ -442,7 +442,7 @@
 protected:
     VkPipelineVertexInputStateCreateInfo          m_vi_state;
     VkPipelineInputAssemblyStateCreateInfo        m_ia_state;
-    VkPipelineRasterStateCreateInfo               m_rs_state;
+    VkPipelineRasterizationStateCreateInfo               m_rs_state;
     VkPipelineColorBlendStateCreateInfo           m_cb_state;
     VkPipelineDepthStencilStateCreateInfo         m_ds_state;
     VkPipelineViewportStateCreateInfo             m_vp_state;
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index 90944de..610374a 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -70,9 +70,9 @@
     return handles;
 }
 
-VkMemoryAllocInfo get_resource_alloc_info(const vk_testing::Device &dev, const VkMemoryRequirements &reqs, VkMemoryPropertyFlags mem_props)
+VkMemoryAllocateInfo get_resource_alloc_info(const vk_testing::Device &dev, const VkMemoryRequirements &reqs, VkMemoryPropertyFlags mem_props)
 {
-    VkMemoryAllocInfo info = vk_testing::DeviceMemory::alloc_info(reqs.size, 0);
+    VkMemoryAllocateInfo info = vk_testing::DeviceMemory::alloc_info(reqs.size, 0);
     dev.phy().set_memory_type(reqs.memoryTypeBits, &info, mem_props);
 
     return info;
@@ -207,7 +207,7 @@
     return exts;
 }
 
-bool PhysicalDevice::set_memory_type(const uint32_t type_bits, VkMemoryAllocInfo *info, const VkFlags properties, const VkFlags forbid) const
+bool PhysicalDevice::set_memory_type(const uint32_t type_bits, VkMemoryAllocateInfo *info, const VkFlags properties, const VkFlags forbid) const
 {
      uint32_t type_mask = type_bits;
      // Search memtypes to find first index with those properties
@@ -392,9 +392,9 @@
     vkUpdateDescriptorSets(handle(), writes.size(), writes.data(), copies.size(), copies.data());
 }
 
-void Queue::submit(const std::vector<const CmdBuffer *> &cmds, Fence &fence)
+void Queue::submit(const std::vector<const CommandBuffer *> &cmds, Fence &fence)
 {
-    const std::vector<VkCmdBuffer> cmd_handles = make_handles<VkCmdBuffer>(cmds);
+    const std::vector<VkCommandBuffer> cmd_handles = make_handles<VkCommandBuffer>(cmds);
     VkSubmitInfo submit_info;
     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     submit_info.pNext = NULL;
@@ -408,12 +408,12 @@
     EXPECT(vkQueueSubmit(handle(), 1, &submit_info, fence.handle()) == VK_SUCCESS);
 }
 
-void Queue::submit(const CmdBuffer &cmd, Fence &fence)
+void Queue::submit(const CommandBuffer &cmd, Fence &fence)
 {
-    submit(std::vector<const CmdBuffer*>(1, &cmd), fence);
+    submit(std::vector<const CommandBuffer*>(1, &cmd), fence);
 }
 
-void Queue::submit(const CmdBuffer &cmd)
+void Queue::submit(const CommandBuffer &cmd)
 {
     Fence fence;
     submit(cmd, fence);
@@ -430,9 +430,9 @@
         vkFreeMemory(device(), handle(), NULL);
 }
 
-void DeviceMemory::init(const Device &dev, const VkMemoryAllocInfo &info)
+void DeviceMemory::init(const Device &dev, const VkMemoryAllocateInfo &info)
 {
-    NON_DISPATCHABLE_HANDLE_INIT(vkAllocMemory, dev, &info);
+    NON_DISPATCHABLE_HANDLE_INIT(vkAllocateMemory, dev, &info);
 }
 
 const void *DeviceMemory::map(VkFlags flags) const
@@ -749,12 +749,12 @@
     std::vector<VkDescriptorSet> set_handles;
     set_handles.resize(layout_handles.size());
 
-    VkDescriptorSetAllocInfo alloc_info = {};
+    VkDescriptorSetAllocateInfo alloc_info = {};
     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
     alloc_info.setLayoutCount = layout_handles.size();
     alloc_info.descriptorPool = handle();
     alloc_info.pSetLayouts = layout_handles.data();
-    VkResult err = vkAllocDescriptorSets(device(), &alloc_info, set_handles.data());
+    VkResult err = vkAllocateDescriptorSets(device(), &alloc_info, set_handles.data());
     EXPECT(err == VK_SUCCESS);
 
     std::vector<DescriptorSet *> sets;
@@ -788,46 +788,46 @@
     }
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(CmdPool, vkDestroyCommandPool)
+NON_DISPATCHABLE_HANDLE_DTOR(CommandPool, vkDestroyCommandPool)
 
-void CmdPool::init(const Device &dev, const VkCmdPoolCreateInfo &info)
+void CommandPool::init(const Device &dev, const VkCommandPoolCreateInfo &info)
 {
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateCommandPool, dev, &info);
 }
 
 
-CmdBuffer::~CmdBuffer()
+CommandBuffer::~CommandBuffer()
 {
     if (initialized()) {
-        VkCmdBuffer cmds[] = { handle() };
+        VkCommandBuffer cmds[] = { handle() };
         vkFreeCommandBuffers(dev_handle_, cmd_pool_, 1, cmds);
     }
 }
 
-void CmdBuffer::init(const Device &dev, const VkCmdBufferAllocInfo &info)
+void CommandBuffer::init(const Device &dev, const VkCommandBufferAllocateInfo &info)
 {
-    VkCmdBuffer cmd;
+    VkCommandBuffer cmd;
 
-    // Make sure cmdPool is set
-    assert(info.cmdPool);
+    // Make sure commandPool is set
+    assert(info.commandPool);
 
-    if (EXPECT(vkAllocCommandBuffers(dev.handle(), &info, &cmd) == VK_SUCCESS)) {
+    if (EXPECT(vkAllocateCommandBuffers(dev.handle(), &info, &cmd) == VK_SUCCESS)) {
         Handle::init(cmd);
         dev_handle_ = dev.handle();
-        cmd_pool_ = info.cmdPool;
+        cmd_pool_ = info.commandPool;
     }
 }
 
-void CmdBuffer::begin(const VkCmdBufferBeginInfo *info)
+void CommandBuffer::begin(const VkCommandBufferBeginInfo *info)
 {
     EXPECT(vkBeginCommandBuffer(handle(), info) == VK_SUCCESS);
 }
 
-void CmdBuffer::begin()
+void CommandBuffer::begin()
 {
-    VkCmdBufferBeginInfo info = {};
-    info.flags = VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-    info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    VkCommandBufferBeginInfo info = {};
+    info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+    info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     info.renderPass = VK_NULL_HANDLE;
     info.subpass = 0;
     info.framebuffer = VK_NULL_HANDLE;
@@ -835,12 +835,12 @@
     begin(&info);
 }
 
-void CmdBuffer::end()
+void CommandBuffer::end()
 {
     EXPECT(vkEndCommandBuffer(handle()) == VK_SUCCESS);
 }
 
-void CmdBuffer::reset(VkCmdBufferResetFlags flags)
+void CommandBuffer::reset(VkCommandBufferResetFlags flags)
 {
     EXPECT(vkResetCommandBuffer(handle(), flags) == VK_SUCCESS);
 }
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index f723de2..6bfc416 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -54,8 +54,8 @@
 class PipelineLayout;
 class DescriptorSetPool;
 class DescriptorSet;
-class CmdBuffer;
-class CmdPool;
+class CommandBuffer;
+class CommandPool;
 
 std::vector<VkLayerProperties> GetGlobalLayers();
 std::vector<VkExtensionProperties> GetGlobalExtensions();
@@ -124,7 +124,7 @@
     VkPhysicalDeviceMemoryProperties memory_properties() const;
     std::vector<VkQueueFamilyProperties> queue_properties() const;
 
-    bool set_memory_type(const uint32_t type_bits, VkMemoryAllocInfo *info, const VkMemoryPropertyFlags properties,
+    bool set_memory_type(const uint32_t type_bits, VkMemoryAllocateInfo *info, const VkMemoryPropertyFlags properties,
                              const VkMemoryPropertyFlags forbid = 0) const;
 
     // vkEnumerateDeviceExtensionProperties()
@@ -224,9 +224,9 @@
     explicit Queue(VkQueue queue, int index) : Handle(queue) {family_index_ = index;}
 
     // vkQueueSubmit()
-    void submit(const std::vector<const CmdBuffer *> &cmds, Fence &fence);
-    void submit(const CmdBuffer &cmd, Fence &fence);
-    void submit(const CmdBuffer &cmd);
+    void submit(const std::vector<const CommandBuffer *> &cmds, Fence &fence);
+    void submit(const CommandBuffer &cmd, Fence &fence);
+    void submit(const CommandBuffer &cmd);
 
     // vkQueueWaitIdle()
     void wait();
@@ -241,8 +241,8 @@
 public:
     ~DeviceMemory();
 
-    // vkAllocMemory()
-    void init(const Device &dev, const VkMemoryAllocInfo &info);
+    // vkAllocateMemory()
+    void init(const Device &dev, const VkMemoryAllocateInfo &info);
 
     // vkMapMemory()
     const void *map(VkFlags flags) const;
@@ -253,7 +253,7 @@
     // vkUnmapMemory()
     void unmap() const;
 
-    static VkMemoryAllocInfo alloc_info(VkDeviceSize size, uint32_t memory_type_index);
+    static VkMemoryAllocateInfo alloc_info(VkDeviceSize size, uint32_t memory_type_index);
 };
 
 class Fence : public internal::NonDispHandle<VkFence> {
@@ -323,9 +323,9 @@
     void init(const Device &dev, const VkBufferCreateInfo &info) { init(dev, info, 0); }
     void init(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags mem_props) { init(dev, create_info(size, 0), mem_props); }
     void init(const Device &dev, VkDeviceSize size) { init(dev, size, 0); }
-    void init_as_src(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs) { init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT), reqs); }
-    void init_as_dst(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs) { init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT), reqs); }
-    void init_as_src_and_dst(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs) { init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT | VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT), reqs); }
+    void init_as_src(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs) { init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT), reqs); }
+    void init_as_dst(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs) { init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_DST_BIT), reqs); }
+    void init_as_src_and_dst(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs) { init(dev, create_info(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT), reqs); }
     void init_no_mem(const Device &dev, const VkBufferCreateInfo &info);
 
     // get the internal memory
@@ -537,7 +537,7 @@
     void setDynamicUsage(bool isDynamic) { dynamic_usage_ = isDynamic; }
     bool getDynamicUsage() { return dynamic_usage_; }
 
-    // vkAllocDescriptorSets()
+    // vkAllocateDescriptorSets()
     std::vector<DescriptorSet *> alloc_sets(const Device &dev, const std::vector<const DescriptorSetLayout *> &layouts);
     std::vector<DescriptorSet *> alloc_sets(const Device &dev, const DescriptorSetLayout &layout, uint32_t count);
     DescriptorSet *alloc_sets(const Device &dev, const DescriptorSetLayout &layout);
@@ -560,56 +560,56 @@
     DescriptorPool* containing_pool_;
 };
 
-class CmdPool : public internal::NonDispHandle<VkCmdPool> {
+class CommandPool : public internal::NonDispHandle<VkCommandPool> {
 public:
-    ~CmdPool();
+    ~CommandPool();
 
-    explicit CmdPool() : NonDispHandle() {}
-    explicit CmdPool(const Device &dev, const VkCmdPoolCreateInfo &info) { init(dev, info); }
+    explicit CommandPool() : NonDispHandle() {}
+    explicit CommandPool(const Device &dev, const VkCommandPoolCreateInfo &info) { init(dev, info); }
 
-    void init(const Device &dev, const VkCmdPoolCreateInfo &info);
+    void init(const Device &dev, const VkCommandPoolCreateInfo &info);
 
-    static VkCmdPoolCreateInfo create_info(uint32_t queue_family_index);
+    static VkCommandPoolCreateInfo create_info(uint32_t queue_family_index);
 };
 
-inline VkCmdPoolCreateInfo CmdPool::create_info(uint32_t queue_family_index)
+inline VkCommandPoolCreateInfo CommandPool::create_info(uint32_t queue_family_index)
 {
-    VkCmdPoolCreateInfo info = {};
-    info.sType = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO;
+    VkCommandPoolCreateInfo info = {};
+    info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
     info.queueFamilyIndex = queue_family_index;
     return info;
 }
 
-class CmdBuffer : public internal::Handle<VkCmdBuffer> {
+class CommandBuffer : public internal::Handle<VkCommandBuffer> {
 public:
-    ~CmdBuffer();
+    ~CommandBuffer();
 
-    explicit CmdBuffer() : Handle() {}
-    explicit CmdBuffer(const Device &dev, const VkCmdBufferAllocInfo &info) { init(dev, info); }
+    explicit CommandBuffer() : Handle() {}
+    explicit CommandBuffer(const Device &dev, const VkCommandBufferAllocateInfo &info) { init(dev, info); }
 
-    // vkAllocCommandBuffers()
-    void init(const Device &dev, const VkCmdBufferAllocInfo &info);
+    // vkAllocateCommandBuffers()
+    void init(const Device &dev, const VkCommandBufferAllocateInfo &info);
 
     // vkBeginCommandBuffer()
-    void begin(const VkCmdBufferBeginInfo *info);
+    void begin(const VkCommandBufferBeginInfo *info);
     void begin();
 
     // vkEndCommandBuffer()
     // vkResetCommandBuffer()
     void end();
-    void reset(VkCmdBufferResetFlags flags);
-    void reset() { reset(VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT); }
+    void reset(VkCommandBufferResetFlags flags);
+    void reset() { reset(VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT); }
 
-    static VkCmdBufferAllocInfo create_info(VkCmdPool const &pool);
+    static VkCommandBufferAllocateInfo create_info(VkCommandPool const &pool);
 
 private:
     VkDevice dev_handle_;
-    VkCmdPool cmd_pool_;
+    VkCommandPool cmd_pool_;
 };
 
-inline VkMemoryAllocInfo DeviceMemory::alloc_info(VkDeviceSize size, uint32_t memory_type_index)
+inline VkMemoryAllocateInfo DeviceMemory::alloc_info(VkDeviceSize size, uint32_t memory_type_index)
 {
-    VkMemoryAllocInfo info = {};
+    VkMemoryAllocateInfo info = {};
     info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
     info.allocationSize = size;
     info.memoryTypeIndex = memory_type_index;
@@ -698,7 +698,7 @@
     subres.aspect = aspect;
     subres.mipLevel = mip_level;
     subres.baseArrayLayer = array_layer;
-    subres.numLayers = array_size;
+    subres.layerCount = array_size;
     return subres;
 }
 
@@ -734,9 +734,9 @@
     VkImageSubresourceRange range = {};
     range.aspectMask = aspect_mask;
     range.baseMipLevel = base_mip_level;
-    range.numLevels = mip_levels;
+    range.levelCount = mip_levels;
     range.baseArrayLayer = base_array_layer;
-    range.numLayers = num_layers;
+    range.layerCount = num_layers;
     return range;
 }
 
@@ -813,9 +813,9 @@
 {
     VkWriteDescriptorSet write = {};
     write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    write.destSet = set.handle();
-    write.destBinding = binding;
-    write.destArrayElement = array_element;
+    write.dstSet = set.handle();
+    write.dstBinding = binding;
+    write.dstArrayElement = array_element;
     write.descriptorCount = count;
     write.descriptorType = type;
     write.pImageInfo = image_info;
@@ -827,9 +827,9 @@
 {
     VkWriteDescriptorSet write = {};
     write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    write.destSet = set.handle();
-    write.destBinding = binding;
-    write.destArrayElement = array_element;
+    write.dstSet = set.handle();
+    write.dstBinding = binding;
+    write.dstArrayElement = array_element;
     write.descriptorCount = count;
     write.descriptorType = type;
     write.pBufferInfo = buffer_info;
@@ -841,9 +841,9 @@
 {
     VkWriteDescriptorSet write = {};
     write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    write.destSet = set.handle();
-    write.destBinding = binding;
-    write.destArrayElement = array_element;
+    write.dstSet = set.handle();
+    write.dstBinding = binding;
+    write.dstArrayElement = array_element;
     write.descriptorCount = count;
     write.descriptorType = type;
     write.pTexelBufferView = buffer_views;
@@ -877,19 +877,19 @@
     copy.srcSet = src_set.handle();
     copy.srcBinding = src_binding;
     copy.srcArrayElement = src_array_element;
-    copy.destSet = dst_set.handle();
-    copy.destBinding = dst_binding;
-    copy.destArrayElement = dst_array_element;
+    copy.dstSet = dst_set.handle();
+    copy.dstBinding = dst_binding;
+    copy.dstArrayElement = dst_array_element;
     copy.descriptorCount = count;
 
     return copy;
 }
 
-inline VkCmdBufferAllocInfo CmdBuffer::create_info(VkCmdPool const &pool)
+inline VkCommandBufferAllocateInfo CommandBuffer::create_info(VkCommandPool const &pool)
 {
-    VkCmdBufferAllocInfo info = {};
-    info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO;
-    info.cmdPool = pool;
+    VkCommandBufferAllocateInfo info = {};
+    info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO;
+    info.commandPool = pool;
     info.bufferCount = 1;
     return info;
 }
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index 05ce639..edae4f4 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -91,7 +91,7 @@
 
 typedef struct _SwapchainBuffers {
     VkImage image;
-    VkCmdBuffer cmd;
+    VkCommandBuffer cmd;
     VkImageView view;
 } SwapchainBuffers;
 
@@ -115,8 +115,8 @@
 protected:
     vk_testing::Device                    &m_device;
     vk_testing::Queue                     &m_queue;
-    vk_testing::CmdPool                    m_cmdpool;
-    vk_testing::CmdBuffer                  m_cmdbuf;
+    vk_testing::CommandPool                    m_cmdpool;
+    vk_testing::CommandBuffer                  m_cmdbuf;
 
 private:
 #ifdef _WIN32
@@ -308,7 +308,7 @@
     VkImageObj displayImage(image->device());
     VkMemoryPropertyFlags reqs = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
 
-    displayImage.init(image->extent().width, image->extent().height, image->format(), VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, VK_IMAGE_TILING_LINEAR, reqs);
+    displayImage.init(image->extent().width, image->extent().height, image->format(), VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_LINEAR, reqs);
     displayImage.CopyImage(*image);
 
     filename.append(basename);
@@ -425,7 +425,7 @@
     VkImageObj displayImage(image->device());
     VkMemoryPropertyFlags reqs = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
 
-    displayImage.init(image->extent().width, image->extent().height, image->format(), VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, VK_IMAGE_TILING_LINEAR, reqs);
+    displayImage.init(image->extent().width, image->extent().height, image->format(), VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_LINEAR, reqs);
 
     displayImage.CopyImage(*image);
 
@@ -498,8 +498,8 @@
 TestFrameworkVkPresent::TestFrameworkVkPresent(vk_testing::Device &device) :
    m_device(device),
    m_queue(*m_device.graphics_queues()[0]),
-   m_cmdpool(m_device, vk_testing::CmdPool::create_info(m_device.graphics_queue_node_index_)),
-   m_cmdbuf(m_device, vk_testing::CmdBuffer::create_info(m_cmdpool.handle()))
+   m_cmdpool(m_device, vk_testing::CommandPool::create_info(m_device.graphics_queue_node_index_)),
+   m_cmdbuf(m_device, vk_testing::CommandBuffer::create_info(m_cmdpool.handle()))
 {
     m_quit = false;
     m_pause = false;
@@ -547,14 +547,14 @@
     memoryBarrier.outputMask = VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT;
     memoryBarrier.inputMask = 0;
     memoryBarrier.oldLayout = VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR;
-    memoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL;
+    memoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
     memoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-    memoryBarrier.destQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    memoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
     memoryBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
     memoryBarrier.subresourceRange.baseMipLevel = 0;
-    memoryBarrier.subresourceRange.numLevels = 1;
+    memoryBarrier.subresourceRange.levelCount = 1;
     memoryBarrier.subresourceRange.baseArrayLayer = 0;
-    memoryBarrier.subresourceRange.numLayers = 1;
+    memoryBarrier.subresourceRange.layerCount = 1;
     memoryBarrier.image = m_buffers[m_current_buffer].image;
     VkImageMemoryBarrier *pmemory_barrier = &memoryBarrier;
     vkCmdPipelineBarrier(m_cmdbuf.handle(), VK_PIPELINE_STAGE_ALL_GPU_COMMANDS, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
@@ -567,16 +567,16 @@
 
     vkCmdCopyBufferToImage(m_cmdbuf.handle(),
         buf.handle(),
-        m_buffers[m_current_buffer].image, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
+        m_buffers[m_current_buffer].image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
         1, &region);
 
-    memoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL;
+    memoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
     memoryBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR;
     vkCmdPipelineBarrier(m_cmdbuf.handle(), VK_PIPELINE_STAGE_ALL_GPU_COMMANDS, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                          0, 1, (const void * const*)&pmemory_barrier);
     m_cmdbuf.end();
 
-    VkCmdBuffer cmdBufs[1];
+    VkCommandBuffer cmdBufs[1];
     cmdBufs[0] = m_cmdbuf.handle();
 
     // Wait for the present complete semaphore to be signaled to ensure
@@ -910,7 +910,7 @@
     }
 
     // We want to blit to the swap chain, ensure the driver supports it.  Color is always supported, per WSI spec.
-    assert((surfProperties.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT) != 0);
+    assert((surfProperties.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT) != 0);
 
     VkSwapchainCreateInfoKHR swap_chain = {};
     swap_chain.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
@@ -921,7 +921,7 @@
     swap_chain.imageColorSpace = m_color_space;
     swap_chain.imageExtent.width = swapchainExtent.width;
     swap_chain.imageExtent.height = swapchainExtent.height;
-    swap_chain.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT |
+    swap_chain.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_DST_BIT |
                                  VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
     swap_chain.preTransform = preTransform;
     swap_chain.imageArraySize = 1;
@@ -958,9 +958,9 @@
         color_image_view.format = m_format;
         color_image_view.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
         color_image_view.subresourceRange.baseMipLevel = 0;
-        color_image_view.subresourceRange.numLevels = 1;
+        color_image_view.subresourceRange.levelCount = 1;
         color_image_view.subresourceRange.baseArrayLayer = 0;
-        color_image_view.subresourceRange.numLayers = 1;
+        color_image_view.subresourceRange.layerCount = 1;
 
         m_buffers[i].image = swapchainImages[i];
 
@@ -981,10 +981,10 @@
 {
     VkResult U_ASSERT_ONLY err;
 
-    VkCmdBufferBeginInfo cmd_buf_info = {};
-    cmd_buf_info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
+    VkCommandBufferBeginInfo cmd_buf_info = {};
+    cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     cmd_buf_info.pNext = NULL;
-    cmd_buf_info.flags = VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+    cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
     cmd_buf_info.renderPass = { VK_NULL_HANDLE };
     cmd_buf_info.subpass = 0;
     cmd_buf_info.framebuffer = { VK_NULL_HANDLE };
@@ -1002,11 +1002,11 @@
     image_memory_barrier.image = image;
     image_memory_barrier.subresourceRange.aspectMask = aspectMask;
     image_memory_barrier.subresourceRange.baseMipLevel = 0;
-    image_memory_barrier.subresourceRange.numLevels = 1;
+    image_memory_barrier.subresourceRange.levelCount = 1;
     image_memory_barrier.subresourceRange.baseArrayLayer = 0;
-    image_memory_barrier.subresourceRange.numLayers = 1;
+    image_memory_barrier.subresourceRange.layerCount = 1;
 
-    if (new_image_layout == VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL) {
+    if (new_image_layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
         /* Make sure anything that was copying from this image has completed */
         image_memory_barrier.inputMask = VK_MEMORY_INPUT_TRANSFER_BIT;
     }
@@ -1026,7 +1026,7 @@
     err = vkEndCommandBuffer(m_cmdbuf.handle());
     assert(!err);
 
-    const VkCmdBuffer cmd_bufs[] = { m_cmdbuf.handle() };
+    const VkCommandBuffer cmd_bufs[] = { m_cmdbuf.handle() };
     VkFence nullFence = { VK_NULL_HANDLE };
     VkSubmitInfo submit_info;
     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 13a1510..dbce97b 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_NUM(%s.numericFormat)" % (name, 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))
         if output_param:
             return ("%p", "(void*)*%s" % name)
         if vk_helper.is_type(vk_type, 'struct') and '*' not in vk_type:
@@ -231,7 +231,7 @@
             ggep_body.append('    {')
             ggep_body.append('        "%s",' % layer)
             ggep_body.append('        VK_API_VERSION, // specVersion')
-            ggep_body.append('        VK_MAKE_VERSION(0, 1, 0), // implVersion')
+            ggep_body.append('        VK_MAKE_VERSION(0, 1, 0), // implementationVersion')
             ggep_body.append('        "layer: %s",' % layer)
             ggep_body.append('    }')
             ggep_body.append('};')
@@ -846,30 +846,30 @@
         header_txt.append('    return retVal;')
         header_txt.append('}')
         header_txt.append('')
-        header_txt.append('void interpret_memBarriers(const void* const* ppMemBarriers, uint32_t memBarrierCount)')
+        header_txt.append('void interpret_memBarriers(const void* const* ppMemoryBarriers, uint32_t memoryBarrierCount)')
         header_txt.append('{')
-        header_txt.append('    if (ppMemBarriers) {')
+        header_txt.append('    if (ppMemoryBarriers) {')
         header_txt.append('        string tmp_str;')
-        header_txt.append('        for (uint32_t i = 0; i < memBarrierCount; i++) {')
-        header_txt.append('            switch(*(VkStructureType*)ppMemBarriers[i])')
+        header_txt.append('        for (uint32_t i = 0; i < memoryBarrierCount; i++) {')
+        header_txt.append('            switch(*(VkStructureType*)ppMemoryBarriers[i])')
         header_txt.append('            {')
         header_txt.append('                case VK_STRUCTURE_TYPE_MEMORY_BARRIER:')
-        header_txt.append('                    tmp_str = vk_print_vkmemorybarrier((VkMemoryBarrier*)ppMemBarriers[i], "    ");')
+        header_txt.append('                    tmp_str = vk_print_vkmemorybarrier((VkMemoryBarrier*)ppMemoryBarriers[i], "    ");')
         header_txt.append('                    break;')
         header_txt.append('                case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:')
-        header_txt.append('                    tmp_str = vk_print_vkbuffermemorybarrier((VkBufferMemoryBarrier*)ppMemBarriers[i], "    ");')
+        header_txt.append('                    tmp_str = vk_print_vkbuffermemorybarrier((VkBufferMemoryBarrier*)ppMemoryBarriers[i], "    ");')
         header_txt.append('                    break;')
         header_txt.append('                case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:')
-        header_txt.append('                    tmp_str = vk_print_vkimagememorybarrier((VkImageMemoryBarrier*)ppMemBarriers[i], "    ");')
+        header_txt.append('                    tmp_str = vk_print_vkimagememorybarrier((VkImageMemoryBarrier*)ppMemoryBarriers[i], "    ");')
         header_txt.append('                    break;')
         header_txt.append('                default:')
         header_txt.append('                    break;')
         header_txt.append('            }')
         header_txt.append('')
         header_txt.append('            if (StreamControl::writeAddress == true) {')
-        header_txt.append('                (*outputStream) << "   ppMemBarriers[" << i << "] (" << &ppMemBarriers[i] << ")" << endl << tmp_str << endl;')
+        header_txt.append('                (*outputStream) << "   ppMemoryBarriers[" << i << "] (" << &ppMemoryBarriers[i] << ")" << endl << tmp_str << endl;')
         header_txt.append('            } else {')
-        header_txt.append('                (*outputStream) << "   ppMemBarriers[" << i << "] (address)" << endl << "    address" << endl;')
+        header_txt.append('                (*outputStream) << "   ppMemoryBarriers[" << i << "] (address)" << endl << "    address" << endl;')
         header_txt.append('            }')
         header_txt.append('        }')
         header_txt.append('    }')
@@ -970,7 +970,7 @@
         funcs = []
         sp_param_dict = {} # Store 'index' for struct param to print, or an name of binding "Count" param for array to print
         create_params = 0 # Num of params at end of function that are created and returned as output values
-        if 'AllocDescriptorSets' in proto.name:
+        if 'AllocateDescriptorSets' in proto.name:
             create_params = -1
         elif 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:
             create_params = -1
@@ -1053,9 +1053,9 @@
                     log_func += '\n%s(*outputStream) << "   %s (" << %s << ")" << endl << tmp_str << endl;' % (indent, local_name, local_name)
                     indent = indent[4:]
                     log_func += '\n%s}' % (indent)
-                elif 'memBarrierCount' == sp_param_dict[sp_index]: # call helper function
-                    log_func += '\n%sif (ppMemBarriers) {' % (indent)
-                    log_func += '\n%s    interpret_memBarriers(ppMemBarriers, memBarrierCount);' % (indent)
+                elif 'memoryBarrierCount' == sp_param_dict[sp_index]: # call helper function
+                    log_func += '\n%sif (ppMemoryBarriers) {' % (indent)
+                    log_func += '\n%s    interpret_memBarriers(ppMemoryBarriers, memoryBarrierCount);' % (indent)
                     log_func += '\n%s}' % (indent)
                 else: # We have a count value stored to iterate over an array
                     print_cast = ''
@@ -1368,7 +1368,7 @@
         gedi_txt.append('%s' % self.lineinfo.get())
         gedi_txt.append('void vkDestroyInstance(')
         gedi_txt.append('VkInstance instance,')
-        gedi_txt.append('const VkAllocCallbacks* pAllocator)')
+        gedi_txt.append('const VkAllocationCallbacks* pAllocator)')
         gedi_txt.append('{')
         gedi_txt.append('    loader_platform_thread_lock_mutex(&objLock);')
         gedi_txt.append('    validate_object(instance, instance);')
@@ -1417,7 +1417,7 @@
         gedd_txt.append('%s' % self.lineinfo.get())
         gedd_txt.append('void vkDestroyDevice(')
         gedd_txt.append('VkDevice device,')
-        gedd_txt.append('const VkAllocCallbacks* pAllocator)')
+        gedd_txt.append('const VkAllocationCallbacks* pAllocator)')
         gedd_txt.append('{')
         gedd_txt.append('    loader_platform_thread_lock_mutex(&objLock);')
         gedd_txt.append('    validate_object(device, device);')
@@ -1458,7 +1458,7 @@
         cbv_txt.append('%s' % self.lineinfo.get())
         for o in ['VkPipeline',
                   'VkPipelineLayout', 'VkBuffer', 'VkEvent', 'VkQueryPool', 'VkRenderPass', 'VkFramebuffer']:
-            cbv_txt.append('static VkBool32 validate_object(VkCmdBuffer dispatchable_object, %s object)' % (o))
+            cbv_txt.append('static VkBool32 validate_object(VkCommandBuffer dispatchable_object, %s object)' % (o))
             cbv_txt.append('{')
             cbv_txt.append('    if (%sMap.find((void*)object) == %sMap.end()) {' % (o, o))
             cbv_txt.append('        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
@@ -1480,7 +1480,7 @@
         for objectName, objectTypeEnum in obj_type_mapping.items():
             obj_type_mapping[objectName] = ucc_to_U_C_C(objectTypeEnum);
         # Command Buffer Object doesn't follow the rule.
-        obj_type_mapping['VkCmdBuffer'] = "VK_OBJECT_TYPE_COMMAND_BUFFER"
+        obj_type_mapping['VkCommandBuffer'] = "VK_OBJECT_TYPE_COMMAND_BUFFER"
         obj_type_mapping['VkShaderModule'] = "VK_OBJECT_TYPE_SHADER_MODULE"
 
         explicit_object_tracker_functions = [
@@ -1490,7 +1490,7 @@
             "CreateDevice",
             "GetDeviceQueue",
             "QueueBindSparse",
-            "AllocDescriptorSets",
+            "AllocateDescriptorSets",
             "FreeDescriptorSets",
             "MapMemory",
             "UnmapMemory",
@@ -1678,7 +1678,7 @@
 class ThreadingSubcommand(Subcommand):
     thread_check_dispatchable_objects = [
         "VkQueue",
-        "VkCmdBuffer",
+        "VkCommandBuffer",
     ]
     thread_check_nondispatchable_objects = [
         "VkDeviceMemory",
@@ -1693,7 +1693,7 @@
         'VkPhysicalDevice' : 'VK_OBJECT_TYPE_PHYSICAL_DEVICE',
         'VkDevice' : 'VK_OBJECT_TYPE_DEVICE',
         'VkQueue' : 'VK_OBJECT_TYPE_QUEUE',
-        'VkCmdBuffer' : 'VK_OBJECT_TYPE_COMMAND_BUFFER',
+        'VkCommandBuffer' : 'VK_OBJECT_TYPE_COMMAND_BUFFER',
         'VkFence' : 'VK_OBJECT_TYPE_FENCE',
         'VkDeviceMemory' : 'VK_OBJECT_TYPE_DEVICE_MEMORY',
         'VkBuffer' : 'VK_OBJECT_TYPE_BUFFER',
@@ -1714,7 +1714,7 @@
         'VkDescriptorPool' : 'VK_OBJECT_TYPE_DESCRIPTOR_POOL',
         'VkDescriptorSet' : 'VK_OBJECT_TYPE_DESCRIPTOR_SET',
         'VkFramebuffer' : 'VK_OBJECT_TYPE_FRAMEBUFFER',
-        'VkCmdPool' : 'VK_OBJECT_TYPE_CMD_POOL',
+        'VkCommandPool' : 'VK_OBJECT_TYPE_COMMAND_POOL',
     }
     def generate_useObject(self, ty):
         obj_type = self.thread_check_object_types[ty]
@@ -1817,13 +1817,13 @@
             funcs.append('%s' % self.lineinfo.get())
             funcs.append('%s%s\n' % (qual, decl) +
                      '{\n'
-                     '    for (uint32_t i=0; i<memRangeCount; i++) {\n'
-                     '        useObject((const void *) %s, pMemRanges[i].mem);\n' % proto.params[0].name +
+                     '    for (uint32_t i=0; i<memoryRangeCount; i++) {\n'
+                     '        useObject((const void *) %s, pMemoryRanges[i].mem);\n' % proto.params[0].name +
                      '    }\n'
                      '    VkLayerDispatchTable *pDeviceTable = get_dispatch_table(Threading_%s_table_map, %s);\n' % (table, proto.params[0].name) +
                      '    %s pDeviceTable->%s;\n' % (ret_val, proto.c_call()) +
-                     '    for (uint32_t i=0; i<memRangeCount; i++) {\n'
-                     '        finishUsingObject(pMemRanges[i].mem);\n'
+                     '    for (uint32_t i=0; i<memoryRangeCount; i++) {\n'
+                     '        finishUsingObject(pMemoryRanges[i].mem);\n'
                      '    }\n'
                      '%s' % (stmt) +
                      '}')
@@ -1853,7 +1853,7 @@
         elif proto.params[0].ty == "VkPhysicalDevice":
             return None
         # Functions changing command buffers need thread safe use of first parameter
-        if proto.params[0].ty == "VkCmdBuffer":
+        if proto.params[0].ty == "VkCommandBuffer":
             funcs.append('%s' % self.lineinfo.get())
             funcs.append('%s%s\n' % (qual, decl) +
                      '{\n'
diff --git a/vk_helper.py b/vk_helper.py
index 2e3a994..069dbdc 100755
--- a/vk_helper.py
+++ b/vk_helper.py
@@ -364,6 +364,12 @@
         else:
             struct_name += caps_struct_name[char_idx].lower()
         char_idx += 1
+
+    if struct_name.endswith("AllocInfo"):
+        struct_name = struct_name[:-9] + "AllocateInfo"
+    if struct_name.endswith("RasterStateCreateInfo"):
+        struct_name = struct_name[:-21] + "RasterizationStateCreateInfo"
+
     return struct_name
 
 # class for writing common file elements
@@ -1248,7 +1254,7 @@
                 if self.struct_dict[s][m]['dyn_array']:
                     if self.struct_dict[s][m]['full_type'].count('*') > 1:
                         if not is_type(self.struct_dict[s][m]['type'], 'struct') and not 'char' in self.struct_dict[s][m]['type'].lower():
-                            if 'ppMemBarriers' == self.struct_dict[s][m]['name']:
+                            if 'ppMemoryBarriers' == self.struct_dict[s][m]['name']:
                                 # TODO : For now be conservative and consider all memBarrier ptrs as largest possible struct
                                 sh_funcs.append('%sstructSize += pStruct->%s*(sizeof(%s*) + sizeof(VkImageMemoryBarrier));' % (indent, self.struct_dict[s][m]['array_size'], self.struct_dict[s][m]['type']))
                             else:
diff --git a/vulkan.py b/vulkan.py
index 7c38a37..e03917c 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -188,7 +188,7 @@
         "VkDevice",
         "VkQueue",
         "VkSemaphore",
-        "VkCmdBuffer",
+        "VkCommandBuffer",
         "VkFence",
         "VkDeviceMemory",
         "VkBuffer",
@@ -208,17 +208,17 @@
         "VkDescriptorPool",
         "VkDescriptorSet",
         "VkFramebuffer",
-        "VkCmdPool",
+        "VkCommandPool",
     ],
     protos=[
         Proto("VkResult", "CreateInstance",
             [Param("const VkInstanceCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkInstance*", "pInstance")]),
 
         Proto("void", "DestroyInstance",
             [Param("VkInstance", "instance"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "EnumeratePhysicalDevices",
             [Param("VkInstance", "instance"),
@@ -267,12 +267,12 @@
         Proto("VkResult", "CreateDevice",
             [Param("VkPhysicalDevice", "physicalDevice"),
              Param("const VkDeviceCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkDevice*", "pDevice")]),
 
         Proto("void", "DestroyDevice",
             [Param("VkDevice", "device"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "EnumerateInstanceExtensionProperties",
             [Param("const char*", "pLayerName"),
@@ -312,16 +312,16 @@
         Proto("VkResult", "DeviceWaitIdle",
             [Param("VkDevice", "device")]),
 
-        Proto("VkResult", "AllocMemory",
+        Proto("VkResult", "AllocateMemory",
             [Param("VkDevice", "device"),
-             Param("const VkMemoryAllocInfo*", "pAllocInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
-             Param("VkDeviceMemory*", "pMem")]),
+             Param("const VkMemoryAllocateInfo*", "pAllocateInfo"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
+             Param("VkDeviceMemory*", "pMemory")]),
 
         Proto("void", "FreeMemory",
             [Param("VkDevice", "device"),
              Param("VkDeviceMemory", "mem"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "MapMemory",
             [Param("VkDevice", "device"),
@@ -337,13 +337,13 @@
 
         Proto("VkResult", "FlushMappedMemoryRanges",
             [Param("VkDevice", "device"),
-             Param("uint32_t", "memRangeCount"),
-             Param("const VkMappedMemoryRange*", "pMemRanges")]),
+             Param("uint32_t", "memoryRangeCount"),
+             Param("const VkMappedMemoryRange*", "pMemoryRanges")]),
 
         Proto("VkResult", "InvalidateMappedMemoryRanges",
             [Param("VkDevice", "device"),
-             Param("uint32_t", "memRangeCount"),
-             Param("const VkMappedMemoryRange*", "pMemRanges")]),
+             Param("uint32_t", "memoryRangeCount"),
+             Param("const VkMappedMemoryRange*", "pMemoryRanges")]),
 
         Proto("void", "GetDeviceMemoryCommitment",
             [Param("VkDevice", "device"),
@@ -354,13 +354,13 @@
             [Param("VkDevice", "device"),
              Param("VkBuffer", "buffer"),
              Param("VkDeviceMemory", "mem"),
-             Param("VkDeviceSize", "memOffset")]),
+             Param("VkDeviceSize", "memoryOffset")]),
 
         Proto("VkResult", "BindImageMemory",
             [Param("VkDevice", "device"),
              Param("VkImage", "image"),
              Param("VkDeviceMemory", "mem"),
-             Param("VkDeviceSize", "memOffset")]),
+             Param("VkDeviceSize", "memoryOffset")]),
 
         Proto("void", "GetBufferMemoryRequirements",
             [Param("VkDevice", "device"),
@@ -397,13 +397,13 @@
         Proto("VkResult", "CreateFence",
             [Param("VkDevice", "device"),
              Param("const VkFenceCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkFence*", "pFence")]),
 
         Proto("void", "DestroyFence",
             [Param("VkDevice", "device"),
              Param("VkFence", "fence"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "ResetFences",
             [Param("VkDevice", "device"),
@@ -424,24 +424,24 @@
         Proto("VkResult", "CreateSemaphore",
             [Param("VkDevice", "device"),
              Param("const VkSemaphoreCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkSemaphore*", "pSemaphore")]),
 
         Proto("void", "DestroySemaphore",
             [Param("VkDevice", "device"),
              Param("VkSemaphore", "semaphore"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateEvent",
             [Param("VkDevice", "device"),
              Param("const VkEventCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkEvent*", "pEvent")]),
 
         Proto("void", "DestroyEvent",
             [Param("VkDevice", "device"),
              Param("VkEvent", "event"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "GetEventStatus",
             [Param("VkDevice", "device"),
@@ -458,13 +458,13 @@
         Proto("VkResult", "CreateQueryPool",
             [Param("VkDevice", "device"),
              Param("const VkQueryPoolCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkQueryPool*", "pQueryPool")]),
 
         Proto("void", "DestroyQueryPool",
             [Param("VkDevice", "device"),
              Param("VkQueryPool", "queryPool"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "GetQueryPoolResults",
             [Param("VkDevice", "device"),
@@ -479,35 +479,35 @@
         Proto("VkResult", "CreateBuffer",
             [Param("VkDevice", "device"),
              Param("const VkBufferCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkBuffer*", "pBuffer")]),
 
         Proto("void", "DestroyBuffer",
             [Param("VkDevice", "device"),
              Param("VkBuffer", "buffer"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateBufferView",
             [Param("VkDevice", "device"),
              Param("const VkBufferViewCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkBufferView*", "pView")]),
 
         Proto("void", "DestroyBufferView",
             [Param("VkDevice", "device"),
              Param("VkBufferView", "bufferView"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateImage",
             [Param("VkDevice", "device"),
              Param("const VkImageCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkImage*", "pImage")]),
 
         Proto("void", "DestroyImage",
             [Param("VkDevice", "device"),
              Param("VkImage", "image"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("void", "GetImageSubresourceLayout",
             [Param("VkDevice", "device"),
@@ -518,46 +518,46 @@
         Proto("VkResult", "CreateImageView",
             [Param("VkDevice", "device"),
              Param("const VkImageViewCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkImageView*", "pView")]),
 
         Proto("void", "DestroyImageView",
             [Param("VkDevice", "device"),
              Param("VkImageView", "imageView"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateShaderModule",
             [Param("VkDevice", "device"),
              Param("const VkShaderModuleCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkShaderModule*", "pShaderModule")]),
 
         Proto("void", "DestroyShaderModule",
             [Param("VkDevice", "device"),
              Param("VkShaderModule", "shaderModule"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateShader",
             [Param("VkDevice", "device"),
              Param("const VkShaderCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkShader*", "pShader")]),
 
         Proto("void", "DestroyShader",
             [Param("VkDevice", "device"),
              Param("VkShader", "shader"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreatePipelineCache",
             [Param("VkDevice", "device"),
              Param("const VkPipelineCacheCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkPipelineCache*", "pPipelineCache")]),
 
         Proto("void", "DestroyPipelineCache",
             [Param("VkDevice", "device"),
              Param("VkPipelineCache", "pipelineCache"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "GetPipelineCacheData",
             [Param("VkDevice", "device"),
@@ -567,7 +567,7 @@
 
         Proto("VkResult", "MergePipelineCaches",
             [Param("VkDevice", "device"),
-             Param("VkPipelineCache", "destCache"),
+             Param("VkPipelineCache", "dstCache"),
              Param("uint32_t", "srcCacheCount"),
              Param("const VkPipelineCache*", "pSrcCaches")]),
 
@@ -576,7 +576,7 @@
              Param("VkPipelineCache", "pipelineCache"),
              Param("uint32_t", "createInfoCount"),
              Param("const VkGraphicsPipelineCreateInfo*", "pCreateInfos"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkPipeline*", "pPipelines")]),
 
         Proto("VkResult", "CreateComputePipelines",
@@ -584,66 +584,66 @@
              Param("VkPipelineCache", "pipelineCache"),
              Param("uint32_t", "createInfoCount"),
              Param("const VkComputePipelineCreateInfo*", "pCreateInfos"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkPipeline*", "pPipelines")]),
 
         Proto("void", "DestroyPipeline",
             [Param("VkDevice", "device"),
              Param("VkPipeline", "pipeline"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreatePipelineLayout",
             [Param("VkDevice", "device"),
              Param("const VkPipelineLayoutCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkPipelineLayout*", "pPipelineLayout")]),
 
         Proto("void", "DestroyPipelineLayout",
             [Param("VkDevice", "device"),
              Param("VkPipelineLayout", "pipelineLayout"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateSampler",
             [Param("VkDevice", "device"),
              Param("const VkSamplerCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkSampler*", "pSampler")]),
 
         Proto("void", "DestroySampler",
             [Param("VkDevice", "device"),
              Param("VkSampler", "sampler"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateDescriptorSetLayout",
             [Param("VkDevice", "device"),
              Param("const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkDescriptorSetLayout*", "pSetLayout")]),
 
         Proto("void", "DestroyDescriptorSetLayout",
             [Param("VkDevice", "device"),
              Param("VkDescriptorSetLayout", "descriptorSetLayout"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateDescriptorPool",
             [Param("VkDevice", "device"),
              Param("const VkDescriptorPoolCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkDescriptorPool*", "pDescriptorPool")]),
 
         Proto("void", "DestroyDescriptorPool",
             [Param("VkDevice", "device"),
              Param("VkDescriptorPool", "descriptorPool"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "ResetDescriptorPool",
             [Param("VkDevice", "device"),
              Param("VkDescriptorPool", "descriptorPool"),
              Param("VkDescriptorPoolResetFlags", "flags")]),
 
-        Proto("VkResult", "AllocDescriptorSets",
+        Proto("VkResult", "AllocateDescriptorSets",
             [Param("VkDevice", "device"),
-             Param("const VkDescriptorSetAllocInfo*", "pAllocInfo"),
+             Param("const VkDescriptorSetAllocateInfo*", "pAllocateInfo"),
              Param("VkDescriptorSet*", "pDescriptorSets")]),
 
         Proto("VkResult", "FreeDescriptorSets",
@@ -662,24 +662,24 @@
         Proto("VkResult", "CreateFramebuffer",
             [Param("VkDevice", "device"),
              Param("const VkFramebufferCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkFramebuffer*", "pFramebuffer")]),
 
         Proto("void", "DestroyFramebuffer",
             [Param("VkDevice", "device"),
              Param("VkFramebuffer", "framebuffer"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateRenderPass",
             [Param("VkDevice", "device"),
              Param("const VkRenderPassCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
              Param("VkRenderPass*", "pRenderPass")]),
 
         Proto("void", "DestroyRenderPass",
             [Param("VkDevice", "device"),
              Param("VkRenderPass", "renderPass"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("void", "GetRenderAreaGranularity",
             [Param("VkDevice", "device"),
@@ -688,93 +688,93 @@
 
         Proto("VkResult", "CreateCommandPool",
             [Param("VkDevice", "device"),
-             Param("const VkCmdPoolCreateInfo*", "pCreateInfo"),
-             Param("const VkAllocCallbacks*", "pAllocator"),
-             Param("VkCmdPool*", "pCmdPool")]),
+             Param("const VkCommandPoolCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
+             Param("VkCommandPool*", "pCommandPool")]),
 
         Proto("void", "DestroyCommandPool",
             [Param("VkDevice", "device"),
-             Param("VkCmdPool", "cmdPool"),
-             Param("const VkAllocCallbacks*", "pAllocator")]),
+             Param("VkCommandPool", "commandPool"),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "ResetCommandPool",
             [Param("VkDevice", "device"),
-             Param("VkCmdPool", "cmdPool"),
-             Param("VkCmdPoolResetFlags", "flags")]),
+             Param("VkCommandPool", "commandPool"),
+             Param("VkCommandPoolResetFlags", "flags")]),
 
-        Proto("VkResult", "AllocCommandBuffers",
+        Proto("VkResult", "AllocateCommandBuffers",
             [Param("VkDevice", "device"),
-             Param("const VkCmdBufferAllocInfo*", "pAllocInfo"),
-             Param("VkCmdBuffer*", "pCmdBuffers")]),
+             Param("const VkCommandBufferAllocateInfo*", "pAllocateInfo"),
+             Param("VkCommandBuffer*", "pCommandBuffers")]),
 
         Proto("void", "FreeCommandBuffers",
             [Param("VkDevice", "device"),
-             Param("VkCmdPool", "cmdPool"),
+             Param("VkCommandPool", "commandPool"),
              Param("uint32_t", "commandBufferCount"),
-             Param("const VkCmdBuffer*", "pCommandBuffers")]),
+             Param("const VkCommandBuffer*", "pCommandBuffers")]),
 
         Proto("VkResult", "BeginCommandBuffer",
-            [Param("VkCmdBuffer", "cmdBuffer"),
-             Param("const VkCmdBufferBeginInfo*", "pBeginInfo")]),
+            [Param("VkCommandBuffer", "commandBuffer"),
+             Param("const VkCommandBufferBeginInfo*", "pBeginInfo")]),
 
         Proto("VkResult", "EndCommandBuffer",
-            [Param("VkCmdBuffer", "cmdBuffer")]),
+            [Param("VkCommandBuffer", "commandBuffer")]),
 
         Proto("VkResult", "ResetCommandBuffer",
-            [Param("VkCmdBuffer", "cmdBuffer"),
-             Param("VkCmdBufferResetFlags", "flags")]),
+            [Param("VkCommandBuffer", "commandBuffer"),
+             Param("VkCommandBufferResetFlags", "flags")]),
 
         Proto("void", "CmdBindPipeline",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkPipelineBindPoint", "pipelineBindPoint"),
              Param("VkPipeline", "pipeline")]),
 
         Proto("void", "CmdSetViewport",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("uint32_t", "viewportCount"),
              Param("const VkViewport*", "pViewports")]),
 
         Proto("void", "CmdSetScissor",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("uint32_t", "scissorCount"),
              Param("const VkRect2D*", "pScissors")]),
 
         Proto("void", "CmdSetLineWidth",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("float", "lineWidth")]),
 
         Proto("void", "CmdSetDepthBias",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("float", "depthBiasConstantFactor"),
              Param("float", "depthBiasClamp"),
              Param("float", "depthBiasSlopeFactor")]),
 
         Proto("void", "CmdSetBlendConstants",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("const float[4]", "blendConstants")]),
 
         Proto("void", "CmdSetDepthBounds",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("float", "minDepthBounds"),
              Param("float", "maxDepthBounds")]),
 
         Proto("void", "CmdSetStencilCompareMask",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkStencilFaceFlags", "faceMask"),
              Param("uint32_t", "stencilCompareMask")]),
 
         Proto("void", "CmdSetStencilWriteMask",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkStencilFaceFlags", "faceMask"),
              Param("uint32_t", "stencilWriteMask")]),
 
         Proto("void", "CmdSetStencilReference",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkStencilFaceFlags", "faceMask"),
              Param("uint32_t", "stencilReference")]),
 
         Proto("void", "CmdBindDescriptorSets",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkPipelineBindPoint", "pipelineBindPoint"),
              Param("VkPipelineLayout", "layout"),
              Param("uint32_t", "firstSet"),
@@ -784,27 +784,27 @@
              Param("const uint32_t*", "pDynamicOffsets")]),
 
         Proto("void", "CmdBindIndexBuffer",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkBuffer", "buffer"),
              Param("VkDeviceSize", "offset"),
              Param("VkIndexType", "indexType")]),
 
         Proto("void", "CmdBindVertexBuffers",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("uint32_t", "startBinding"),
              Param("uint32_t", "bindingCount"),
              Param("const VkBuffer*", "pBuffers"),
              Param("const VkDeviceSize*", "pOffsets")]),
 
         Proto("void", "CmdDraw",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("uint32_t", "vertexCount"),
              Param("uint32_t", "instanceCount"),
              Param("uint32_t", "firstVertex"),
              Param("uint32_t", "firstInstance")]),
 
         Proto("void", "CmdDrawIndexed",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("uint32_t", "indexCount"),
              Param("uint32_t", "instanceCount"),
              Param("uint32_t", "firstIndex"),
@@ -812,88 +812,88 @@
              Param("uint32_t", "firstInstance")]),
 
         Proto("void", "CmdDrawIndirect",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkBuffer", "buffer"),
              Param("VkDeviceSize", "offset"),
              Param("uint32_t", "drawCount"),
              Param("uint32_t", "stride")]),
 
         Proto("void", "CmdDrawIndexedIndirect",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkBuffer", "buffer"),
              Param("VkDeviceSize", "offset"),
              Param("uint32_t", "drawCount"),
              Param("uint32_t", "stride")]),
 
         Proto("void", "CmdDispatch",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("uint32_t", "x"),
              Param("uint32_t", "y"),
              Param("uint32_t", "z")]),
 
         Proto("void", "CmdDispatchIndirect",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkBuffer", "buffer"),
              Param("VkDeviceSize", "offset")]),
 
         Proto("void", "CmdCopyBuffer",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkBuffer", "srcBuffer"),
-             Param("VkBuffer", "destBuffer"),
+             Param("VkBuffer", "dstBuffer"),
              Param("uint32_t", "regionCount"),
              Param("const VkBufferCopy*", "pRegions")]),
 
         Proto("void", "CmdCopyImage",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkImage", "srcImage"),
              Param("VkImageLayout", "srcImageLayout"),
-             Param("VkImage", "destImage"),
-             Param("VkImageLayout", "destImageLayout"),
+             Param("VkImage", "dstImage"),
+             Param("VkImageLayout", "dstImageLayout"),
              Param("uint32_t", "regionCount"),
              Param("const VkImageCopy*", "pRegions")]),
 
         Proto("void", "CmdBlitImage",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkImage", "srcImage"),
              Param("VkImageLayout", "srcImageLayout"),
-             Param("VkImage", "destImage"),
-             Param("VkImageLayout", "destImageLayout"),
+             Param("VkImage", "dstImage"),
+             Param("VkImageLayout", "dstImageLayout"),
              Param("uint32_t", "regionCount"),
              Param("const VkImageBlit*", "pRegions"),
              Param("VkFilter", "filter")]),
 
         Proto("void", "CmdCopyBufferToImage",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkBuffer", "srcBuffer"),
-             Param("VkImage", "destImage"),
-             Param("VkImageLayout", "destImageLayout"),
+             Param("VkImage", "dstImage"),
+             Param("VkImageLayout", "dstImageLayout"),
              Param("uint32_t", "regionCount"),
              Param("const VkBufferImageCopy*", "pRegions")]),
 
         Proto("void", "CmdCopyImageToBuffer",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkImage", "srcImage"),
              Param("VkImageLayout", "srcImageLayout"),
-             Param("VkBuffer", "destBuffer"),
+             Param("VkBuffer", "dstBuffer"),
              Param("uint32_t", "regionCount"),
              Param("const VkBufferImageCopy*", "pRegions")]),
 
         Proto("void", "CmdUpdateBuffer",
-            [Param("VkCmdBuffer", "cmdBuffer"),
-             Param("VkBuffer", "destBuffer"),
-             Param("VkDeviceSize", "destOffset"),
+            [Param("VkCommandBuffer", "commandBuffer"),
+             Param("VkBuffer", "dstBuffer"),
+             Param("VkDeviceSize", "dstOffset"),
              Param("VkDeviceSize", "dataSize"),
              Param("const uint32_t*", "pData")]),
 
         Proto("void", "CmdFillBuffer",
-            [Param("VkCmdBuffer", "cmdBuffer"),
-             Param("VkBuffer", "destBuffer"),
-             Param("VkDeviceSize", "destOffset"),
+            [Param("VkCommandBuffer", "commandBuffer"),
+             Param("VkBuffer", "dstBuffer"),
+             Param("VkDeviceSize", "dstOffset"),
              Param("VkDeviceSize", "size"),
              Param("uint32_t", "data")]),
 
         Proto("void", "CmdClearColorImage",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkImage", "image"),
              Param("VkImageLayout", "imageLayout"),
              Param("const VkClearColorValue*", "pColor"),
@@ -901,7 +901,7 @@
              Param("const VkImageSubresourceRange*", "pRanges")]),
 
         Proto("void", "CmdClearDepthStencilImage",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkImage", "image"),
              Param("VkImageLayout", "imageLayout"),
              Param("const VkClearDepthStencilValue*", "pDepthStencil"),
@@ -909,83 +909,83 @@
              Param("const VkImageSubresourceRange*", "pRanges")]),
 
         Proto("void", "CmdClearAttachments",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("uint32_t", "attachmentCount"),
              Param("const VkClearAttachment*", "pAttachments"),
              Param("uint32_t", "rectCount"),
              Param("const VkClearRect*", "pRects")]),
 
         Proto("void", "CmdResolveImage",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkImage", "srcImage"),
              Param("VkImageLayout", "srcImageLayout"),
-             Param("VkImage", "destImage"),
-             Param("VkImageLayout", "destImageLayout"),
+             Param("VkImage", "dstImage"),
+             Param("VkImageLayout", "dstImageLayout"),
              Param("uint32_t", "regionCount"),
              Param("const VkImageResolve*", "pRegions")]),
 
         Proto("void", "CmdSetEvent",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkEvent", "event"),
              Param("VkPipelineStageFlags", "stageMask")]),
 
         Proto("void", "CmdResetEvent",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkEvent", "event"),
              Param("VkPipelineStageFlags", "stageMask")]),
 
         Proto("void", "CmdWaitEvents",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("uint32_t", "eventCount"),
              Param("const VkEvent*", "pEvents"),
              Param("VkPipelineStageFlags", "srcStageMask"),
-             Param("VkPipelineStageFlags", "destStageMask"),
-             Param("uint32_t", "memBarrierCount"),
-             Param("const void* const*", "ppMemBarriers")]),
+             Param("VkPipelineStageFlags", "dstStageMask"),
+             Param("uint32_t", "memoryBarrierCount"),
+             Param("const void* const*", "ppMemoryBarriers")]),
 
         Proto("void", "CmdPipelineBarrier",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkPipelineStageFlags", "srcStageMask"),
-             Param("VkPipelineStageFlags", "destStageMask"),
+             Param("VkPipelineStageFlags", "dstStageMask"),
              Param("VkDependencyFlags", "dependencyFlags"),
-             Param("uint32_t", "memBarrierCount"),
-             Param("const void* const*", "ppMemBarriers")]),
+             Param("uint32_t", "memoryBarrierCount"),
+             Param("const void* const*", "ppMemoryBarriers")]),
 
         Proto("void", "CmdBeginQuery",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkQueryPool", "queryPool"),
              Param("uint32_t", "slot"),
              Param("VkQueryControlFlags", "flags")]),
 
         Proto("void", "CmdEndQuery",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkQueryPool", "queryPool"),
              Param("uint32_t", "slot")]),
 
         Proto("void", "CmdResetQueryPool",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkQueryPool", "queryPool"),
              Param("uint32_t", "startQuery"),
              Param("uint32_t", "queryCount")]),
 
         Proto("void", "CmdWriteTimestamp",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkPipelineStageFlagBits", "pipelineStage"),
              Param("VkQueryPool", "queryPool"),
              Param("uint32_t", "slot")]),
 
         Proto("void", "CmdCopyQueryPoolResults",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkQueryPool", "queryPool"),
              Param("uint32_t", "startQuery"),
              Param("uint32_t", "queryCount"),
-             Param("VkBuffer", "destBuffer"),
-             Param("VkDeviceSize", "destOffset"),
+             Param("VkBuffer", "dstBuffer"),
+             Param("VkDeviceSize", "dstOffset"),
              Param("VkDeviceSize", "stride"),
              Param("VkQueryResultFlags", "flags")]),
 
         Proto("void", "CmdPushConstants",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkPipelineLayout", "layout"),
              Param("VkShaderStageFlags", "stageFlags"),
              Param("uint32_t", "offset"),
@@ -993,21 +993,21 @@
              Param("const void*", "values")]),
 
         Proto("void", "CmdBeginRenderPass",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("const VkRenderPassBeginInfo*", "pRenderPassBegin"),
              Param("VkRenderPassContents", "contents")]),
 
         Proto("void", "CmdNextSubpass",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("VkRenderPassContents", "contents")]),
 
         Proto("void", "CmdEndRenderPass",
-            [Param("VkCmdBuffer", "cmdBuffer")]),
+            [Param("VkCommandBuffer", "commandBuffer")]),
 
         Proto("void", "CmdExecuteCommands",
-            [Param("VkCmdBuffer", "cmdBuffer"),
-             Param("uint32_t", "cmdBuffersCount"),
-             Param("const VkCmdBuffer*", "pCmdBuffers")]),
+            [Param("VkCommandBuffer", "commandBuffer"),
+             Param("uint32_t", "commandBuffersCount"),
+             Param("const VkCommandBuffer*", "pCommandBuffers")]),
     ],
 )
 
@@ -1098,11 +1098,11 @@
     objects=[],
     protos=[
         Proto("void", "CmdDbgMarkerBegin",
-            [Param("VkCmdBuffer", "cmdBuffer"),
+            [Param("VkCommandBuffer", "commandBuffer"),
              Param("const char*", "pMarker")]),
 
         Proto("void", "CmdDbgMarkerEnd",
-            [Param("VkCmdBuffer", "cmdBuffer")]),
+            [Param("VkCommandBuffer", "commandBuffer")]),
 
         Proto("VkResult", "DbgSetObjectTag",
             [Param("VkDevice", "device"),
@@ -1126,11 +1126,11 @@
     "VkPhysicalDevice",
     "VkDevice",
     "VkQueue",
-    "VkCmdBuffer",
+    "VkCommandBuffer",
 ]
 
 object_non_dispatch_list = [
-    "VkCmdPool",
+    "VkCommandPool",
     "VkFence",
     "VkDeviceMemory",
     "VkBuffer",