update vulkan.h for multi-pass command buffers (V131, #14075)

Minimal changes to keep everything building and functioning.

TODO: Need to port draw_state to use new VkAttachmentView structure.

18 files changed, 693 insertions, 676 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 932e36cf..9db21d96 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -321,7 +321,7 @@ struct demo {
         VkDeviceMemory mem;
         VkCmdBuffer cmd;
 
-        VkColorAttachmentView view;
+        VkAttachmentView view;
     } buffers[DEMO_BUFFER_COUNT];
 
     struct {
@@ -329,7 +329,7 @@ struct demo {
 
         VkImage image;
         VkDeviceMemory mem;
-        VkDepthStencilView view;
+        VkAttachmentView view;
     } depth;
 
     struct texture_object textures[DEMO_TEXTURE_COUNT];
@@ -483,17 +483,29 @@ static void demo_draw_build_cmd(struct demo *demo, VkCmdBuffer cmd_buf)
         .flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
             VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT,
     };
-    const VkRenderPassBegin rp_begin = {
+    const VkClearValue clear_values[2] = {
+        [0] = { .color.f32 = { 0.2f, 0.2f, 0.2f, 0.2f } },
+        [1] = { .ds = { 1.0f, 0 } },
+    };
+    const VkRenderPassBeginInfo rp_begin = {
+        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+        .pNext = NULL,
         .renderPass = demo->render_pass,
         .framebuffer = demo->framebuffers[demo->current_buffer],
-        .contents = VK_RENDER_PASS_CONTENTS_INLINE,
+        .renderArea.offset.x = 0,
+        .renderArea.offset.y = 0,
+        .renderArea.extent.width = demo->width,
+        .renderArea.extent.height = demo->height,
+        .attachmentCount = 2,
+        .pAttachmentClearValues = clear_values,
     };
     VkResult U_ASSERT_ONLY err;
 
     err = vkBeginCommandBuffer(cmd_buf, &cmd_buf_info);
     assert(!err);
 
-    vkCmdBeginRenderPass(cmd_buf, &rp_begin);
+    vkCmdBeginRenderPass(cmd_buf, &rp_begin, VK_RENDER_PASS_CONTENTS_INLINE);
+
     vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS,
                                   demo->pipeline);
     vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout,
@@ -591,8 +603,8 @@ static void demo_prepare_buffers(struct demo *demo)
     assert(!err && images_size == sizeof(images));
 
     for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
-        VkColorAttachmentViewCreateInfo color_attachment_view = {
-            .sType = VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
+        VkAttachmentViewCreateInfo color_attachment_view = {
+            .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
             .pNext = NULL,
             .format = demo->format,
             .mipLevel = 0,
@@ -610,7 +622,7 @@ static void demo_prepare_buffers(struct demo *demo)
 
         color_attachment_view.image = demo->buffers[i].image;
 
-        err = vkCreateColorAttachmentView(demo->device,
+        err = vkCreateAttachmentView(demo->device,
                 &color_attachment_view, &demo->buffers[i].view);
         assert(!err);
     }
@@ -638,8 +650,8 @@ static void demo_prepare_depth(struct demo *demo)
         .allocationSize = 0,
         .memoryTypeIndex = 0,
     };
-    VkDepthStencilViewCreateInfo view = {
-        .sType = VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO,
+    VkAttachmentViewCreateInfo view = {
+        .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
         .pNext = NULL,
         .image = VK_NULL_HANDLE,
         .mipLevel = 0,
@@ -685,8 +697,7 @@ static void demo_prepare_depth(struct demo *demo)
 
     /* create image view */
     view.image = demo->depth.image;
-    err = vkCreateDepthStencilView(demo->device, &view,
-            &demo->depth.view);
+    err = vkCreateAttachmentView(demo->device, &view, &demo->depth.view);
     assert(!err);
 }
 
@@ -1179,40 +1190,64 @@ static void demo_prepare_descriptor_layout(struct demo *demo)
 
 static void demo_prepare_render_pass(struct demo *demo)
 {
-    const VkClearColorValue clear_color = {
-        .f32 = { 0.2f, 0.2f, 0.2f, 0.2f },
+    const VkAttachmentDescription attachments[2] = {
+        [0] = {
+            .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION,
+            .pNext = NULL,
+            .format = demo->format,
+            .samples = 1,
+            .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
+            .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
+            .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+            .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+            .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+            .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+        },
+        [1] = {
+            .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION,
+            .pNext = NULL,
+            .format = demo->depth.format,
+            .samples = 1,
+            .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
+            .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+            .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+            .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+            .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+            .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+        },
+    };
+    const VkAttachmentReference color_reference = {
+        .attachment = 0,
+        .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+    };
+    const VkSubpassDescription subpass = {
+        .sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION,
+        .pNext = NULL,
+        .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
+        .flags = 0,
+        .inputCount = 0,
+        .inputAttachments = NULL,
+        .colorCount = 1,
+        .colorAttachments = &color_reference,
+        .resolveAttachments = NULL,
+        .depthStencilAttachment = {
+            .attachment = 1,
+            .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+        },
+        .preserveCount = 0,
+        .preserveAttachments = NULL,
     };
-    const float clear_depth = 1.0f;
-    VkResult U_ASSERT_ONLY err;
-    const VkImageLayout color_layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-    const VkAttachmentLoadOp color_load_op = VK_ATTACHMENT_LOAD_OP_CLEAR;
-    const VkAttachmentStoreOp color_store_op = VK_ATTACHMENT_STORE_OP_STORE;
     const VkRenderPassCreateInfo rp_info = {
         .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
         .pNext = NULL,
-        .renderArea.offset.x = 0,
-        .renderArea.offset.y = 0,
-        .renderArea.extent.width = demo->width,
-        .renderArea.extent.height = demo->height,
-        .colorAttachmentCount = 1,
-        .extent.width = demo->width,
-        .extent.height = demo->height,
-        .sampleCount = 1,
-        .layers = 1,
-        .pColorFormats = &demo->format,
-        .pColorLayouts = &color_layout,
-        .pColorLoadOps = &color_load_op,
-        .pColorStoreOps = &color_store_op,
-        .pColorLoadClearValues = &clear_color,
-        .depthStencilFormat = demo->depth.format,
-        .depthStencilLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-        .depthLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
-        .depthLoadClearValue = clear_depth,
-        .depthStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
-        .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-        .stencilLoadClearValue = 0,
-        .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+        .attachmentCount = 2,
+        .pAttachments = attachments,
+        .subpassCount = 1,
+        .pSubpasses = &subpass,
+        .dependencyCount = 0,
+        .pDependencies = NULL,
     };
+    VkResult U_ASSERT_ONLY err;
 
     err = vkCreateRenderPass(demo->device, &rp_info, &demo->render_pass);
     assert(!err);
@@ -1397,7 +1432,6 @@ static void demo_prepare_pipeline(struct demo *demo)
     cb.sType = VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
     VkPipelineCbAttachmentState att_state[1];
     memset(att_state, 0, sizeof(att_state));
-    att_state[0].format = demo->format;
     att_state[0].channelWriteMask = 0xf;
     att_state[0].blendEnable = VK_FALSE;
     cb.attachmentCount = 1;
@@ -1409,7 +1443,6 @@ static void demo_prepare_pipeline(struct demo *demo)
 
     memset(&ds, 0, sizeof(ds));
     ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
-    ds.format = demo->depth.format;
     ds.depthTestEnable = VK_TRUE;
     ds.depthWriteEnable = VK_TRUE;
     ds.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
@@ -1447,6 +1480,9 @@ static void demo_prepare_pipeline(struct demo *demo)
     pipeline.pVpState = &vp;
     pipeline.pDsState = &ds;
     pipeline.pStages  = shaderStages;
+    pipeline.renderPass = demo->render_pass;
+    pipeline.subpass = 0;
+
     memset(&pipelineCache, 0, sizeof(pipelineCache));
     pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 
@@ -1589,21 +1625,22 @@ static void demo_prepare_descriptor_set(struct demo *demo)
 
 static void demo_prepare_framebuffers(struct demo *demo)
 {
-    VkColorAttachmentBindInfo color_attachment = {
-        .view = VK_NULL_HANDLE,
-        .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-    };
-    const VkDepthStencilBindInfo depth_stencil = {
-        .view = demo->depth.view,
-        .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+    VkAttachmentBindInfo attachments[2] = {
+        [0] = {
+            .view = VK_NULL_HANDLE,
+            .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+        },
+        [1] = {
+            .view = demo->depth.view,
+            .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+        },
     };
     const VkFramebufferCreateInfo fb_info = {
          .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
          .pNext = NULL,
-         .colorAttachmentCount = 1,
-         .pColorAttachments = &color_attachment,
-         .pDepthStencilAttachment = &depth_stencil,
-         .sampleCount = 1,
+         .renderPass = demo->render_pass,
+         .attachmentCount = 2,
+         .pAttachments = attachments,
          .width  = demo->width,
          .height = demo->height,
          .layers = 1,
@@ -1612,7 +1649,7 @@ static void demo_prepare_framebuffers(struct demo *demo)
     uint32_t i;
 
     for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
-        color_attachment.view = demo->buffers[i].view;
+        attachments[0].view = demo->buffers[i].view;
         err = vkCreateFramebuffer(demo->device, &fb_info, &demo->framebuffers[i]);
         assert(!err);
     }
@@ -1695,7 +1732,7 @@ static void demo_cleanup(struct demo *demo)
     }
     demo->fpDestroySwapChainWSI(demo->swap_chain);
 
-    vkDestroyObject(demo->device, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW, demo->depth.view);
+    vkDestroyObject(demo->device, VK_OBJECT_TYPE_ATTACHMENT_VIEW, demo->depth.view);
     vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->depth.image);
     vkFreeMemory(demo->device, demo->depth.mem);
 
@@ -1704,7 +1741,7 @@ static void demo_cleanup(struct demo *demo)
     vkFreeMemory(demo->device, demo->uniform_data.mem);
 
     for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
-        vkDestroyObject(demo->device, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW, demo->buffers[i].view);
+        vkDestroyObject(demo->device, VK_OBJECT_TYPE_ATTACHMENT_VIEW, demo->buffers[i].view);
         vkDestroyObject(demo->device, VK_OBJECT_TYPE_COMMAND_BUFFER, demo->buffers[i].cmd);
     }
 
diff --git a/demos/tri.c b/demos/tri.c
index 8276c587..7ffd8a85 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -168,7 +168,7 @@ struct demo {
         VkImage image;
         VkDeviceMemory mem;
 
-        VkColorAttachmentView view;
+        VkAttachmentView view;
     } buffers[DEMO_BUFFER_COUNT];
 
     struct {
@@ -176,7 +176,7 @@ struct demo {
 
         VkImage image;
         VkDeviceMemory mem;
-        VkDepthStencilView view;
+        VkAttachmentView view;
     } depth;
 
     struct texture_object textures[DEMO_TEXTURE_COUNT];
@@ -324,17 +324,28 @@ static void demo_draw_build_cmd(struct demo *demo)
         .flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
             VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT,
     };
-    const VkRenderPassBegin rp_begin = {
+    const VkClearValue clear_values[2] = {
+        [0] = { .color.f32 = { 0.2f, 0.2f, 0.2f, 0.2f } },
+        [1] = { .ds = { 0.9f, 0 } },
+    };
+    const VkRenderPassBeginInfo rp_begin = {
+        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+        .pNext = NULL,
         .renderPass = demo->render_pass,
         .framebuffer = demo->framebuffers[demo->current_buffer],
-        .contents = VK_RENDER_PASS_CONTENTS_INLINE,
+        .renderArea.offset.x = 0,
+        .renderArea.offset.y = 0,
+        .renderArea.extent.width = demo->width,
+        .renderArea.extent.height = demo->height,
+        .attachmentCount = 2,
+        .pAttachmentClearValues = clear_values,
     };
     VkResult U_ASSERT_ONLY err;
 
     err = vkBeginCommandBuffer(demo->draw_cmd, &cmd_buf_info);
     assert(!err);
 
-    vkCmdBeginRenderPass(demo->draw_cmd, &rp_begin);
+    vkCmdBeginRenderPass(demo->draw_cmd, &rp_begin, VK_RENDER_PASS_CONTENTS_INLINE);
     vkCmdBindPipeline(demo->draw_cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
                                   demo->pipeline);
     vkCmdBindDescriptorSets(demo->draw_cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout,
@@ -412,8 +423,8 @@ static void demo_prepare_buffers(struct demo *demo)
     assert(!err && images_size == sizeof(images));
 
     for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
-        VkColorAttachmentViewCreateInfo color_attachment_view = {
-            .sType = VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
+        VkAttachmentViewCreateInfo color_attachment_view = {
+            .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
             .pNext = NULL,
             .format = demo->format,
             .mipLevel = 0,
@@ -431,7 +442,7 @@ static void demo_prepare_buffers(struct demo *demo)
 
         color_attachment_view.image = demo->buffers[i].image;
 
-        err = vkCreateColorAttachmentView(demo->device,
+        err = vkCreateAttachmentView(demo->device,
                 &color_attachment_view, &demo->buffers[i].view);
         assert(!err);
     }
@@ -461,8 +472,8 @@ static void demo_prepare_depth(struct demo *demo)
         .allocationSize = 0,
         .memoryTypeIndex = 0,
     };
-    VkDepthStencilViewCreateInfo view = {
-        .sType = VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO,
+    VkAttachmentViewCreateInfo view = {
+        .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
         .pNext = NULL,
         .image = VK_NULL_HANDLE,
         .mipLevel = 0,
@@ -510,8 +521,7 @@ static void demo_prepare_depth(struct demo *demo)
 
     /* create image view */
     view.image = demo->depth.image;
-    err = vkCreateDepthStencilView(demo->device, &view,
-            &demo->depth.view);
+    err = vkCreateAttachmentView(demo->device, &view, &demo->depth.view);
     assert(!err);
 }
 
@@ -835,40 +845,64 @@ static void demo_prepare_descriptor_layout(struct demo *demo)
 
 static void demo_prepare_render_pass(struct demo *demo)
 {
-    const VkClearColorValue clear_color = {
-        .f32 = { 0.2f, 0.2f, 0.2f, 0.2f },
+    const VkAttachmentDescription attachments[2] = {
+        [0] = {
+            .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION,
+            .pNext = NULL,
+            .format = demo->format,
+            .samples = 1,
+            .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
+            .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
+            .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+            .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+            .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+            .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+        },
+        [1] = {
+            .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION,
+            .pNext = NULL,
+            .format = demo->depth.format,
+            .samples = 1,
+            .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
+            .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+            .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+            .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+            .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+            .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+        },
+    };
+    const VkAttachmentReference color_reference = {
+        .attachment = 0,
+        .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+    };
+    const VkSubpassDescription subpass = {
+        .sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION,
+        .pNext = NULL,
+        .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
+        .flags = 0,
+        .inputCount = 0,
+        .inputAttachments = NULL,
+        .colorCount = 1,
+        .colorAttachments = &color_reference,
+        .resolveAttachments = NULL,
+        .depthStencilAttachment = {
+            .attachment = 1,
+            .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+        },
+        .preserveCount = 0,
+        .preserveAttachments = NULL,
     };
-    const float clear_depth = 0.9f;
-    VkResult U_ASSERT_ONLY err;
-    const VkImageLayout color_layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-    const VkAttachmentLoadOp color_load_op = VK_ATTACHMENT_LOAD_OP_CLEAR;
-    const VkAttachmentStoreOp color_store_op = VK_ATTACHMENT_STORE_OP_STORE;
     const VkRenderPassCreateInfo rp_info = {
         .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
         .pNext = NULL,
-        .renderArea.offset.x = 0,
-        .renderArea.offset.y = 0,
-        .renderArea.extent.width = demo->width,
-        .renderArea.extent.height = demo->height,
-        .colorAttachmentCount = 1,
-        .extent.width = demo->width,
-        .extent.height = demo->height,
-        .sampleCount = 1,
-        .layers = 1,
-        .pColorFormats = &demo->format,
-        .pColorLayouts = &color_layout,
-        .pColorLoadOps = &color_load_op,
-        .pColorStoreOps = &color_store_op,
-        .pColorLoadClearValues = &clear_color,
-        .depthStencilFormat = demo->depth.format,
-        .depthStencilLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-        .depthLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
-        .depthLoadClearValue = clear_depth,
-        .depthStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
-        .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-        .stencilLoadClearValue = 0,
-        .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+        .attachmentCount = 2,
+        .pAttachments = attachments,
+        .subpassCount = 1,
+        .pSubpasses = &subpass,
+        .dependencyCount = 0,
+        .pDependencies = NULL,
     };
+    VkResult U_ASSERT_ONLY err;
 
     err = vkCreateRenderPass(demo->device, &rp_info, &demo->render_pass);
     assert(!err);
@@ -1043,7 +1077,6 @@ static void demo_prepare_pipeline(struct demo *demo)
     cb.sType = VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
     VkPipelineCbAttachmentState att_state[1];
     memset(att_state, 0, sizeof(att_state));
-    att_state[0].format = demo->format;
     att_state[0].channelWriteMask = 0xf;
     att_state[0].blendEnable = VK_FALSE;
     cb.attachmentCount = 1;
@@ -1056,7 +1089,6 @@ static void demo_prepare_pipeline(struct demo *demo)
 
     memset(&ds, 0, sizeof(ds));
     ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
-    ds.format = demo->depth.format;
     ds.depthTestEnable = VK_TRUE;
     ds.depthWriteEnable = VK_TRUE;
     ds.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
@@ -1095,6 +1127,8 @@ static void demo_prepare_pipeline(struct demo *demo)
     pipeline.pVpState = &vp;
     pipeline.pDsState = &ds;
     pipeline.pStages  = shaderStages;
+    pipeline.renderPass = demo->render_pass;
+    pipeline.subpass = 0;
 
     memset(&pipelineCache, 0, sizeof(pipelineCache));
     pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
@@ -1224,21 +1258,22 @@ static void demo_prepare_descriptor_set(struct demo *demo)
 
 static void demo_prepare_framebuffers(struct demo *demo)
 {
-    VkColorAttachmentBindInfo color_attachment = {
-        .view = VK_NULL_HANDLE,
-        .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-    };
-    const VkDepthStencilBindInfo depth_stencil = {
-        .view = demo->depth.view,
-        .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+    VkAttachmentBindInfo attachments[2] = {
+        [0] = {
+            .view = VK_NULL_HANDLE,
+            .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+        },
+        [1] = {
+            .view = demo->depth.view,
+            .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+        },
     };
     const VkFramebufferCreateInfo fb_info = {
          .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
          .pNext = NULL,
-         .colorAttachmentCount = 1,
-         .pColorAttachments = &color_attachment,
-         .pDepthStencilAttachment = &depth_stencil,
-         .sampleCount = 1,
+         .renderPass = demo->render_pass,
+         .attachmentCount = 2,
+         .pAttachments = attachments,
          .width  = demo->width,
          .height = demo->height,
          .layers = 1,
@@ -1247,7 +1282,7 @@ static void demo_prepare_framebuffers(struct demo *demo)
     uint32_t i;
 
     for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
-        color_attachment.view = demo->buffers[i].view;
+        attachments[0].view = demo->buffers[i].view;
         err = vkCreateFramebuffer(demo->device, &fb_info, &demo->framebuffers[i]);
         assert(!err);
     }
@@ -1784,12 +1819,12 @@ static void demo_cleanup(struct demo *demo)
         vkDestroyObject(demo->device, VK_OBJECT_TYPE_SAMPLER, demo->textures[i].sampler);
     }
 
-    vkDestroyObject(demo->device, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW, demo->depth.view);
+    vkDestroyObject(demo->device, VK_OBJECT_TYPE_ATTACHMENT_VIEW, demo->depth.view);
     vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->depth.image);
     vkFreeMemory(demo->device, demo->depth.mem);
 
     for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
-        vkDestroyObject(demo->device, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW, demo->buffers[i].view);
+        vkDestroyObject(demo->device, VK_OBJECT_TYPE_ATTACHMENT_VIEW, demo->buffers[i].view);
     }
     demo->fpDestroySwapChainWSI(demo->swap_chain);
 
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 32b8f5f6..6e4ea00d 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -236,13 +236,13 @@ static struct nulldrv_gpu *nulldrv_gpu(VkPhysicalDevice gpu)
 }
 
 static VkResult nulldrv_rt_view_create(struct nulldrv_dev *dev,
-                                const VkColorAttachmentViewCreateInfo *info,
+                                const VkAttachmentViewCreateInfo *info,
                                 struct nulldrv_rt_view **view_ret)
 {
     struct nulldrv_rt_view *view;
 
     view = (struct nulldrv_rt_view *) nulldrv_base_create(dev, sizeof(*view),
-            VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW);
+            VK_OBJECT_TYPE_ATTACHMENT_VIEW);
     if (!view)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -344,27 +344,6 @@ static VkResult nulldrv_mem_alloc(struct nulldrv_dev *dev,
     return VK_SUCCESS;
 }
 
-static VkResult nulldrv_ds_view_create(struct nulldrv_dev *dev,
-                                const VkDepthStencilViewCreateInfo *info,
-                                struct nulldrv_ds_view **view_ret)
-{
-    struct nulldrv_img *img = nulldrv_img(info->image);
-    struct nulldrv_ds_view *view;
-
-    view = (struct nulldrv_ds_view *) nulldrv_base_create(dev, sizeof(*view),
-            VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW);
-    if (!view)
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-
-    view->img = img;
-
-    view->array_size = info->arraySize;
-
-    *view_ret = view;
-
-    return VK_SUCCESS;
-}
-
 static VkResult nulldrv_sampler_create(struct nulldrv_dev *dev,
                                 const VkSamplerCreateInfo *info,
                                 struct nulldrv_sampler **sampler_ret)
@@ -1978,10 +1957,10 @@ ICD_EXPORT VkResult VKAPI vkCreateImageView(
             (struct nulldrv_img_view **) pView);
 }
 
-ICD_EXPORT VkResult VKAPI vkCreateColorAttachmentView(
+ICD_EXPORT VkResult VKAPI vkCreateAttachmentView(
     VkDevice                                  device,
-    const VkColorAttachmentViewCreateInfo* pCreateInfo,
-    VkColorAttachmentView*                  pView)
+    const VkAttachmentViewCreateInfo* pCreateInfo,
+    VkAttachmentView*                  pView)
 {
     NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
@@ -1990,19 +1969,6 @@ ICD_EXPORT VkResult VKAPI vkCreateColorAttachmentView(
             (struct nulldrv_rt_view **) pView);
 }
 
-ICD_EXPORT VkResult VKAPI vkCreateDepthStencilView(
-    VkDevice                                  device,
-    const VkDepthStencilViewCreateInfo*   pCreateInfo,
-    VkDepthStencilView*                     pView)
-{
-    NULLDRV_LOG_FUNC;
-    struct nulldrv_dev *dev = nulldrv_dev(device);
-
-    return nulldrv_ds_view_create(dev, pCreateInfo,
-            (struct nulldrv_ds_view **) pView);
-
-}
-
 ICD_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
     VkDevice                                   device,
     const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
@@ -2116,8 +2082,16 @@ ICD_EXPORT VkResult VKAPI vkCreateRenderPass(
 }
 
 ICD_EXPORT void VKAPI vkCmdBeginRenderPass(
-    VkCmdBuffer                              cmdBuffer,
-    const VkRenderPassBegin*                pRenderPassBegin)
+    VkCmdBuffer                                 cmdBuffer,
+    const VkRenderPassBeginInfo*                pRenderPassBegin,
+    VkRenderPassContents                        contents)
+{
+    NULLDRV_LOG_FUNC;
+}
+
+ICD_EXPORT void VKAPI vkCmdNextSubpass(
+    VkCmdBuffer                                 cmdBuffer,
+    VkRenderPassContents                        contents)
 {
     NULLDRV_LOG_FUNC;
 }
diff --git a/icd/nulldrv/nulldrv.h b/icd/nulldrv/nulldrv.h
index 9931b391..8aef6f96 100644
--- a/icd/nulldrv/nulldrv.h
+++ b/icd/nulldrv/nulldrv.h
@@ -108,12 +108,6 @@ struct nulldrv_mem {
     VkDeviceSize size;
 };
 
-struct nulldrv_ds_view {
-    struct nulldrv_obj obj;
-    struct nulldrv_img *img;
-    uint32_t array_size;
-};
-
 struct nulldrv_sampler {
     struct nulldrv_obj obj;
 };
diff --git a/include/vk_layer.h b/include/vk_layer.h
index 3e915b1b..d9e4387f 100644
--- a/include/vk_layer.h
+++ b/include/vk_layer.h
@@ -65,8 +65,7 @@ typedef struct VkLayerDispatchTable_
     PFN_vkCreateImage CreateImage;
     PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout;
     PFN_vkCreateImageView CreateImageView;
-    PFN_vkCreateColorAttachmentView CreateColorAttachmentView;
-    PFN_vkCreateDepthStencilView CreateDepthStencilView;
+    PFN_vkCreateAttachmentView CreateAttachmentView;
     PFN_vkCreateShaderModule CreateShaderModule;
     PFN_vkCreateShader CreateShader;
     PFN_vkCreatePipelineCache CreatePipelineCache;
@@ -126,6 +125,7 @@ typedef struct VkLayerDispatchTable_
     PFN_vkCreateFramebuffer CreateFramebuffer;
     PFN_vkCreateRenderPass CreateRenderPass;
     PFN_vkCmdBeginRenderPass CmdBeginRenderPass;
+    PFN_vkCmdNextSubpass CmdNextSubpass;
     PFN_vkCmdEndRenderPass CmdEndRenderPass;
     PFN_vkCmdExecuteCommands CmdExecuteCommands;
     PFN_vkCreateSwapChainWSI CreateSwapChainWSI;
diff --git a/include/vulkan.h b/include/vulkan.h
index 443a23b9..d738768f 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -77,10 +77,10 @@ VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBuffer, VkNonDispatchable)
 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBufferView, VkNonDispatchable)
 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImage, VkNonDispatchable)
 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImageView, VkNonDispatchable)
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkColorAttachmentView, VkNonDispatchable)
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDepthStencilView, VkNonDispatchable)
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkAttachmentView, VkNonDispatchable)
 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShaderModule, VkNonDispatchable)
 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShader, VkNonDispatchable)
+VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable)
 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipeline, VkNonDispatchable)
 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineCache, VkNonDispatchable)
 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineLayout, VkNonDispatchable)
@@ -98,7 +98,6 @@ VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSemaphore, VkNonDispatchable)
 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkEvent, VkNonDispatchable)
 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkQueryPool, VkNonDispatchable)
 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFramebuffer, VkNonDispatchable)
-VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable)
 
 #define VK_MAX_PHYSICAL_DEVICE_NAME 256
 #define VK_MAX_EXTENSION_NAME       256
@@ -112,6 +111,7 @@ VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable)
 
 
 #define VK_WHOLE_SIZE           UINT64_MAX
+#define VK_ATTACHMENT_UNUSED    UINT32_MAX
 
 #define VK_TRUE  1
 #define VK_FALSE 0
@@ -166,8 +166,7 @@ typedef enum VkAttachmentLoadOp_
 typedef enum VkAttachmentStoreOp_
 {
     VK_ATTACHMENT_STORE_OP_STORE                            = 0x00000000,
-    VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA                     = 0x00000001,
-    VK_ATTACHMENT_STORE_OP_DONT_CARE                        = 0x00000002,
+    VK_ATTACHMENT_STORE_OP_DONT_CARE                        = 0x00000001,
 
     VK_ENUM_RANGE(ATTACHMENT_STORE_OP, STORE, DONT_CARE)
 } VkAttachmentStoreOp;
@@ -748,8 +747,8 @@ typedef enum VkStructureType_
     VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO                      = 1,
     VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO                       = 2,
     VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO                  = 3,
-    VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO       = 4,
-    VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO          = 5,
+    VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO             = 4,
+
     VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO               = 6,
     VK_STRUCTURE_TYPE_SHADER_CREATE_INFO                      = 7,
     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO            = 8,
@@ -792,7 +791,12 @@ typedef enum VkStructureType_
     VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO              = 45,
     VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES                    = 46,
 
-    VK_ENUM_RANGE(STRUCTURE_TYPE, APPLICATION_INFO, EXTENSION_PROPERTIES)
+    VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION                  = 47,
+    VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION                     = 48,
+    VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY                      = 49,
+    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO                  = 50,
+
+    VK_ENUM_RANGE(STRUCTURE_TYPE, APPLICATION_INFO, RENDER_PASS_BEGIN_INFO)
 } VkStructureType;
 
 // Object type enumerant
@@ -808,8 +812,8 @@ typedef enum VkObjectType_
     VK_OBJECT_TYPE_BUFFER_VIEW                              = 7,
     VK_OBJECT_TYPE_IMAGE                                    = 8,
     VK_OBJECT_TYPE_IMAGE_VIEW                               = 9,
-    VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW                    = 10,
-    VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW                       = 11,
+    VK_OBJECT_TYPE_ATTACHMENT_VIEW                          = 10,
+
     VK_OBJECT_TYPE_SHADER_MODULE                            = 12,
     VK_OBJECT_TYPE_SHADER                                   = 13,
     VK_OBJECT_TYPE_PIPELINE                                 = 14,
@@ -941,7 +945,8 @@ typedef enum VkMemoryInputFlagBits_
     VK_MEMORY_INPUT_SHADER_READ_BIT                         = VK_BIT(5),    // Controls input coherency of generic shader reads
     VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT                    = VK_BIT(6),    // Controls input coherency of color attachment reads
     VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT            = VK_BIT(7),    // Controls input coherency of depth/stencil attachment reads
-    VK_MEMORY_INPUT_TRANSFER_BIT                            = VK_BIT(8),    // Controls input coherency of transfer operations
+    VK_MEMORY_INPUT_ATTACHMENT_BIT                          = VK_BIT(8),
+    VK_MEMORY_INPUT_TRANSFER_BIT                            = VK_BIT(9),    // Controls input coherency of transfer operations
 } VkMemoryInputFlagBits;
 
 // Buffer usage flags
@@ -995,6 +1000,7 @@ typedef enum VkImageUsageFlagBits_
     VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                     = VK_BIT(4),    // Can be used as framebuffer color attachment
     VK_IMAGE_USAGE_DEPTH_STENCIL_BIT                        = VK_BIT(5),    // Can be used as framebuffer depth/stencil attachment
     VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT                 = VK_BIT(6),    // Image data not needed outside of rendering
+    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT                     = VK_BIT(7),
 } VkImageUsageFlagBits;
 
 // Image creation flags
@@ -1010,12 +1016,12 @@ typedef enum VkImageCreateFlagBits_
 } VkImageCreateFlagBits;
 
 // Depth-stencil view creation flags
-typedef VkFlags VkDepthStencilViewCreateFlags;
-typedef enum VkDepthStencilViewCreateFlagBits_
+typedef VkFlags VkAttachmentViewCreateFlags;
+typedef enum VkAttachmentViewCreateFlagBits_
 {
-    VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT        = VK_BIT(0),
-    VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT      = VK_BIT(1),
-} VkDepthStencilViewCreateFlagBits;
+    VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT           = VK_BIT(0),
+    VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT         = VK_BIT(1),
+} VkAttachmentViewCreateFlagBits;
 
 // Pipeline creation flags
 typedef VkFlags VkPipelineCreateFlags;
@@ -1079,6 +1085,12 @@ typedef enum VkFormatFeatureFlagBits_
     VK_FORMAT_FEATURE_CONVERSION_BIT                        = VK_BIT(10),   // Format can be used as the source or destination of format converting blits
 } VkFormatFeatureFlagBits;
 
+typedef VkFlags VkSubpassDescriptionFlags;
+typedef enum VkSubpassDescriptionFlagBits_
+{
+    VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT                  = 0x00000001,
+} VkSubpassDescriptionFlagBits;
+
 // Pipeline stage flags
 typedef enum {
     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT                       = VK_BIT(0),
@@ -1584,6 +1596,7 @@ typedef struct VkDescriptorInfo_
     VkBufferView                                bufferView;                 // Buffer view to write to the descriptor (in case it's a buffer descriptor, otherwise should be VK_NULL_HANDLE)
     VkSampler                                   sampler;                    // Sampler to write to the descriptor (in case it's a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor, otherwise should be VK_NULL_HANDLE)
     VkImageView                                 imageView;                  // Image view to write to the descriptor (in case it's a SAMPLED_IMAGE, STORAGE_IMAGE, or COMBINED_IMAGE_SAMPLER descriptor, otherwise should be VK_NULL_HANDLE)
+    VkAttachmentView                            attachmentView;
     VkImageLayout                               imageLayout;                // Layout the image is expected to be in when accessed using this descriptor (only used if <imageView> is not VK_NULL_HANDLE)
 } VkDescriptorInfo;
 
@@ -1720,7 +1733,7 @@ typedef struct VkImageViewCreateInfo_
     VkImageSubresourceRange                     subresourceRange;
 } VkImageViewCreateInfo;
 
-typedef struct VkColorAttachmentViewCreateInfo_
+typedef struct VkAttachmentViewCreateInfo_
 {
     VkStructureType                             sType;                  // Must be VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
     const void*                                 pNext;                  // Pointer to next structure
@@ -1729,32 +1742,8 @@ typedef struct VkColorAttachmentViewCreateInfo_
     uint32_t                                    mipLevel;
     uint32_t                                    baseArraySlice;
     uint32_t                                    arraySize;
-    VkImage                                     msaaResolveImage;
-    VkImageSubresourceRange                     msaaResolveSubResource;
-} VkColorAttachmentViewCreateInfo;
-
-typedef struct VkDepthStencilViewCreateInfo_
-{
-    VkStructureType                             sType;                  // Must be VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO
-    const void*                                 pNext;                  // Pointer to next structure
-    VkImage                                     image;
-    uint32_t                                    mipLevel;
-    uint32_t                                    baseArraySlice;
-    uint32_t                                    arraySize;
-    VkDepthStencilViewCreateFlags               flags;                  // Depth stencil attachment view flags
-} VkDepthStencilViewCreateInfo;
-
-typedef struct VkColorAttachmentBindInfo_
-{
-    VkColorAttachmentView                       view;
-    VkImageLayout                               layout;
-} VkColorAttachmentBindInfo;
-
-typedef struct VkDepthStencilBindInfo_
-{
-    VkDepthStencilView                          view;
-    VkImageLayout                               layout;
-} VkDepthStencilBindInfo;
+    VkAttachmentViewCreateFlags                 flags;                  // attachment view flags
+} VkAttachmentViewCreateInfo;
 
 typedef struct VkBufferCopy_
 {
@@ -2024,7 +2013,6 @@ typedef struct VkPipelineDsStateCreateInfo_
 {
     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO
     const void*                                 pNext;      // Pointer to next structure
-    VkFormat                                    format;
     VkBool32                                    depthTestEnable;
     VkBool32                                    depthWriteEnable;
     VkCompareOp                                 depthCompareOp;
@@ -2050,6 +2038,8 @@ typedef struct VkGraphicsPipelineCreateInfo_
     const VkPipelineCbStateCreateInfo*          pCbState;
     VkPipelineCreateFlags                       flags;      // Pipeline creation flags
     VkPipelineLayout                            layout;     // Interface layout of the pipeline
+    VkRenderPass                                renderPass;
+    uint32_t                                    subpass;
     VkPipeline                                  basePipelineHandle;
     int32_t                                     basePipelineIndex;
 } VkGraphicsPipelineCreateInfo;
@@ -2139,13 +2129,6 @@ typedef struct VkCmdBufferBeginInfo_
     VkFramebuffer                               framebuffer;
 } VkCmdBufferBeginInfo;
 
-typedef struct VkRenderPassBegin_
-{
-    VkRenderPass                                renderPass;
-    VkFramebuffer                               framebuffer;
-    VkRenderPassContents                        contents;
-} VkRenderPassBegin;
-
 // Union allowing specification of floating point, integer, or unsigned integer color data. Actual value selected is based on format.
 typedef union VkClearColorValue_
 {
@@ -2154,29 +2137,88 @@ typedef union VkClearColorValue_
     uint32_t                                    u32[4];
 } VkClearColorValue;
 
-typedef struct VkRenderPassCreateInfo_
+typedef struct VkAttachmentBindInfo_
 {
-    VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
-    const void*                                 pNext;      // Pointer to next structure
+    VkAttachmentView                            view;
+    VkImageLayout                               layout;
+} VkAttachmentBindInfo;
 
-    VkRect2D                                    renderArea;
-    uint32_t                                    colorAttachmentCount;
-    VkExtent2D                                  extent;
-    uint32_t                                    sampleCount;
+typedef struct VkFramebufferCreateInfo_
+{
+    VkStructureType                             sType;  // Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
+    const void*                                 pNext;  // Pointer to next structure
+
+    VkRenderPass                                renderPass;
+    uint32_t                                    attachmentCount;
+    const VkAttachmentBindInfo*                 pAttachments;
+
+    uint32_t                                    width;
+    uint32_t                                    height;
     uint32_t                                    layers;
-    const VkFormat*                             pColorFormats;
-    const VkImageLayout*                        pColorLayouts;
-    const VkAttachmentLoadOp*                   pColorLoadOps;
-    const VkAttachmentStoreOp*                  pColorStoreOps;
-    const VkClearColorValue*                    pColorLoadClearValues;
-    VkFormat                                    depthStencilFormat;
-    VkImageLayout                               depthStencilLayout;
-    VkAttachmentLoadOp                          depthLoadOp;
-    float                                       depthLoadClearValue;
-    VkAttachmentStoreOp                         depthStoreOp;
+} VkFramebufferCreateInfo;
+
+typedef struct VkAttachmentDescription_
+{
+    VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION
+    const void*                                 pNext;      // Pointer to next structure
+
+    VkFormat                                    format;
+    uint32_t                                    samples;
+    VkAttachmentLoadOp                          loadOp;
+    VkAttachmentStoreOp                         storeOp;
     VkAttachmentLoadOp                          stencilLoadOp;
-    uint32_t                                    stencilLoadClearValue;
     VkAttachmentStoreOp                         stencilStoreOp;
+    VkImageLayout                               initialLayout;
+    VkImageLayout                               finalLayout;
+} VkAttachmentDescription;
+
+typedef struct VkAttachmentReference_
+{
+    uint32_t                                    attachment;
+    VkImageLayout                               layout;
+} VkAttachmentReference;
+
+typedef struct VkSubpassDescription_
+{
+    VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION
+    const void*                                 pNext;
+
+    VkPipelineBindPoint                         pipelineBindPoint;
+    VkSubpassDescriptionFlags                   flags;
+    uint32_t                                    inputCount;
+    const VkAttachmentReference*                inputAttachments;
+    uint32_t                                    colorCount;
+    const VkAttachmentReference*                colorAttachments;
+    const VkAttachmentReference*                resolveAttachments;
+    VkAttachmentReference                       depthStencilAttachment;
+    uint32_t                                    preserveCount;
+    const VkAttachmentReference*                preserveAttachments;
+} VkSubpassDescription;
+
+typedef struct VkSubpassDependency_
+{
+    VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY
+    const void*                                 pNext;
+    uint32_t                                    srcSubpass;
+    uint32_t                                    destSubpass;
+    VkPipelineStageFlags                        srcStageMask;
+    VkPipelineStageFlags                        destStageMask;
+    VkMemoryOutputFlags                         outputMask;
+    VkMemoryInputFlags                          inputMask;
+    VkBool32                                    byRegion;
+} VkSubpassDependency;
+
+typedef struct VkRenderPassCreateInfo_
+{
+    VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
+    const void*                                 pNext;      // Pointer to next structure
+
+    uint32_t                                    attachmentCount;
+    const VkAttachmentDescription*              pAttachments;
+    uint32_t                                    subpassCount;
+    const VkSubpassDescription*                 pSubpasses;
+    uint32_t                                    dependencyCount;
+    const VkSubpassDependency*                  pDependencies;
 } VkRenderPassCreateInfo;
 
 typedef struct VkEventCreateInfo_
@@ -2209,20 +2251,29 @@ typedef struct VkQueryPoolCreateInfo_
     VkQueryPipelineStatisticFlags               pipelineStatistics; // Optional
 } VkQueryPoolCreateInfo;
 
-typedef struct VkFramebufferCreateInfo_
+typedef struct VkClearDepthStencilValue_
 {
-    VkStructureType                             sType;  // Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
-    const void*                                 pNext;  // Pointer to next structure
+    float                                       depth;
+    uint32_t                                    stencil;
+} VkClearDepthStencilValue;
 
-    uint32_t                                    colorAttachmentCount;
-    const VkColorAttachmentBindInfo*            pColorAttachments;
-    const VkDepthStencilBindInfo*               pDepthStencilAttachment;
+typedef union VkClearValue_
+{
+    VkClearColorValue                           color;
+    VkClearDepthStencilValue                    ds;
+} VkClearValue;
 
-    uint32_t                                    sampleCount;
-    uint32_t                                    width;
-    uint32_t                                    height;
-    uint32_t                                    layers;
-} VkFramebufferCreateInfo;
+typedef struct VkRenderPassBeginInfo_
+{
+    VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
+    const void*                                 pNext;      // Pointer to next structure
+
+    VkRenderPass                                renderPass;
+    VkFramebuffer                               framebuffer;
+    VkRect2D                                    renderArea;
+    uint32_t                                    attachmentCount;
+    const VkClearValue*                         pAttachmentClearValues;
+} VkRenderPassBeginInfo;
 
 typedef struct VkDrawIndirectCmd_
 {
@@ -2305,8 +2356,7 @@ typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBuffer
 typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
 typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
 typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
-typedef VkResult (VKAPI *PFN_vkCreateColorAttachmentView)(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView);
-typedef VkResult (VKAPI *PFN_vkCreateDepthStencilView)(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView);
+typedef VkResult (VKAPI *PFN_vkCreateAttachmentView)(VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView);
 typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
 typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
 typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
@@ -2365,7 +2415,8 @@ typedef void     (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimes
 typedef void     (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
 typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
 typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
-typedef void     (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin);
+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);
 
@@ -2674,15 +2725,10 @@ VkResult VKAPI vkCreateImageView(
     const VkImageViewCreateInfo*                pCreateInfo,
     VkImageView*                                pView);
 
-VkResult VKAPI vkCreateColorAttachmentView(
-    VkDevice                                    device,
-    const VkColorAttachmentViewCreateInfo*      pCreateInfo,
-    VkColorAttachmentView*                      pView);
-
-VkResult VKAPI vkCreateDepthStencilView(
+VkResult VKAPI vkCreateAttachmentView(
     VkDevice                                    device,
-    const VkDepthStencilViewCreateInfo*         pCreateInfo,
-    VkDepthStencilView*                         pView);
+    const VkAttachmentViewCreateInfo*           pCreateInfo,
+    VkAttachmentView*                           pView);
 
 // Shader functions
 
@@ -3068,7 +3114,12 @@ VkResult VKAPI vkCreateRenderPass(
 
 void VKAPI vkCmdBeginRenderPass(
     VkCmdBuffer                                 cmdBuffer,
-    const VkRenderPassBegin*                    pRenderPassBegin);
+    const VkRenderPassBeginInfo*                pRenderPassBegin,
+    VkRenderPassContents                        contents);
+
+void VKAPI vkCmdNextSubpass(
+    VkCmdBuffer                                 cmdBuffer,
+    VkRenderPassContents                        contents);
 
 void VKAPI vkCmdEndRenderPass(
     VkCmdBuffer                                 cmdBuffer);
diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt
index 8fc23d6c..958387d5 100644
--- a/layers/CMakeLists.txt
+++ b/layers/CMakeLists.txt
@@ -135,7 +135,9 @@ endif()
 
 add_vk_layer(Basic basic.cpp vk_layer_table.cpp)
 add_vk_layer(Multi multi.cpp)
-add_vk_layer(DrawState draw_state.cpp vk_layer_debug_marker_table.cpp vk_layer_table.cpp)
+# TODO: Port DrawState to use VkAttachmentView structure as
+# defined in bug 14075: tiling across render passes
+#add_vk_layer(DrawState draw_state.cpp vk_layer_debug_marker_table.cpp vk_layer_table.cpp)
 add_vk_layer(MemTracker mem_tracker.cpp vk_layer_table.cpp)
 add_vk_layer(ShaderChecker shader_checker.cpp vk_layer_table.cpp)
 add_vk_layer(Image image.cpp vk_layer_table.cpp)
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 0be0af76..cab178b9 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -651,11 +651,36 @@ static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const VkPipelineBin
         // Verify that any MSAA request in PSO matches sample# in bound FB
         uint32_t psoNumSamples = getNumSamples(pipeline);
         if (pCB->activeRenderPass) {
-            VkRenderPassCreateInfo* pRPCI = renderPassMap[pCB->activeRenderPass];
-            VkFramebufferCreateInfo* pFBCI = frameBufferMap[pCB->framebuffer];
-            if ((psoNumSamples != pFBCI->sampleCount) || (psoNumSamples != pRPCI->sampleCount)) {
+            const VkRenderPassCreateInfo* pRPCI = renderPassMap[pCB->activeRenderPass];
+            const VkSubpassDescription* pSD = &pRPCI->pSubpasses[pCB->activeSubpass];
+            int subpassNumSamples = 0;
+            uint32_t i;
+
+            for (i = 0; i < pSD->colorCount; i++) {
+                uint32_t samples;
+
+                if (pSD->colorAttachments[i].attachment == VK_ATTACHMENT_UNUSED)
+                    continue;
+
+                samples = pRPCI->pAttachments[pSD->colorAttachments[i].attachment].samples;
+                if (subpassNumSamples == 0) {
+                    subpassNumSamples = samples;
+                } else if (subpassNumSamples != samples) {
+                    subpassNumSamples = -1;
+                    break;
+                }
+            }
+            if (pSD->depthStencilAttachment.attachment != VK_ATTACHMENT_UNUSED) {
+                const uint32_t samples = pRPCI->pAttachments[pSD->depthStencilAttachment.attachment].samples;
+                if (subpassNumSamples == 0)
+                    subpassNumSamples = samples;
+                else if (subpassNumSamples != samples)
+                    subpassNumSamples = -1;
+            }
+
+            if (psoNumSamples != subpassNumSamples) {
                 log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS",
-                        "Num samples mismatch! Binding PSO (%p) with %u samples while current RenderPass (%p) w/ %u samples uses FB (%p) with %u samples!", (void*)pipeline, psoNumSamples, (void*)pCB->activeRenderPass, pRPCI->sampleCount, (void*)pCB->framebuffer, pFBCI->sampleCount);
+                        "Num samples mismatch! Binding PSO (%p) with %u samples while current RenderPass (%p) w/ %u samples!", (void*)pipeline, psoNumSamples, (void*)pCB->activeRenderPass, subpassNumSamples);
             }
         } else {
             // TODO : I believe it's an error if we reach this point and don't have an activeRenderPass
@@ -2523,13 +2548,9 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFram
     if (VK_SUCCESS == result) {
         // Shadow create info and store in map
         VkFramebufferCreateInfo* localFBCI = new VkFramebufferCreateInfo(*pCreateInfo);
-        if (pCreateInfo->pColorAttachments) {
-            localFBCI->pColorAttachments = new VkColorAttachmentBindInfo[localFBCI->colorAttachmentCount];
-            memcpy((void*)localFBCI->pColorAttachments, pCreateInfo->pColorAttachments, localFBCI->colorAttachmentCount*sizeof(VkColorAttachmentBindInfo));
-        }
-        if (pCreateInfo->pDepthStencilAttachment) {
-            localFBCI->pDepthStencilAttachment = new VkDepthStencilBindInfo[localFBCI->colorAttachmentCount];
-            memcpy((void*)localFBCI->pDepthStencilAttachment, pCreateInfo->pDepthStencilAttachment, localFBCI->colorAttachmentCount*sizeof(VkDepthStencilBindInfo));
+        if (pCreateInfo->pAttachments) {
+            localFBCI->pAttachments = new VkAttachmentBindInfo[localFBCI->attachmentCount];
+            memcpy((void*)localFBCI->pAttachments, pCreateInfo->pAttachments, localFBCI->attachmentCount*sizeof(VkAttachmentBindInfo));
         }
         frameBufferMap[*pFramebuffer] = localFBCI;
     }
@@ -2542,24 +2563,53 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRende
     if (VK_SUCCESS == result) {
         // Shadow create info and store in map
         VkRenderPassCreateInfo* localRPCI = new VkRenderPassCreateInfo(*pCreateInfo);
-        if (pCreateInfo->pColorLoadOps) {
-            localRPCI->pColorLoadOps = new VkAttachmentLoadOp[localRPCI->colorAttachmentCount];
-            memcpy((void*)localRPCI->pColorLoadOps, pCreateInfo->pColorLoadOps, localRPCI->colorAttachmentCount*sizeof(VkAttachmentLoadOp));
-        }
-        if (pCreateInfo->pColorStoreOps) {
-            localRPCI->pColorStoreOps = new VkAttachmentStoreOp[localRPCI->colorAttachmentCount];
-            memcpy((void*)localRPCI->pColorStoreOps, pCreateInfo->pColorStoreOps, localRPCI->colorAttachmentCount*sizeof(VkAttachmentStoreOp));
+        if (pCreateInfo->pAttachments) {
+            localRPCI->pAttachments = new VkAttachmentDescription[localRPCI->attachmentCount];
+            memcpy((void*)localRPCI->pAttachments, pCreateInfo->pAttachments, localRPCI->attachmentCount*sizeof(VkAttachmentDescription));
+        }
+        if (pCreateInfo->pSubpasses) {
+            localRPCI->pSubpasses = new VkSubpassDescription[localRPCI->subpassCount];
+            memcpy((void*)localRPCI->pSubpasses, pCreateInfo->pSubpasses, localRPCI->subpassCount*sizeof(VkSubpassDescription));
+
+            for (uint32_t i = 0; i < localRPCI->subpassCount; i++) {
+                VkSubpassDescription *subpass = (VkSubpassDescription *) &localRPCI->pSubpasses[i];
+                const uint32_t attachmentCount = subpass->inputCount +
+                    subpass->colorCount * (1 + (bool) subpass->resolveAttachments) +
+                    subpass->preserveCount;
+                VkAttachmentReference *attachments = new VkAttachmentReference[attachmentCount];
+
+                memcpy(attachments, subpass->inputAttachments,
+                        sizeof(attachments[0]) * subpass->inputCount);
+                subpass->inputAttachments = attachments;
+                attachments += subpass->inputCount;
+
+                memcpy(attachments, subpass->colorAttachments,
+                        sizeof(attachments[0]) * subpass->colorCount);
+                subpass->colorAttachments = attachments;
+                attachments += subpass->colorCount;
+
+                if (subpass->resolveAttachments) {
+                    memcpy(attachments, subpass->resolveAttachments,
+                            sizeof(attachments[0]) * subpass->colorCount);
+                    subpass->resolveAttachments = attachments;
+                    attachments += subpass->colorCount;
+                }
+
+                memcpy(attachments, subpass->preserveAttachments,
+                        sizeof(attachments[0]) * subpass->preserveCount);
+                subpass->preserveAttachments = attachments;
+            }
         }
-        if (pCreateInfo->pColorLoadClearValues) {
-            localRPCI->pColorLoadClearValues = new VkClearColorValue[localRPCI->colorAttachmentCount];
-            memcpy((void*)localRPCI->pColorLoadClearValues, pCreateInfo->pColorLoadClearValues, localRPCI->colorAttachmentCount*sizeof(VkClearColorValue));
+        if (pCreateInfo->pDependencies) {
+            localRPCI->pDependencies = new VkSubpassDependency[localRPCI->dependencyCount];
+            memcpy((void*)localRPCI->pDependencies, pCreateInfo->pDependencies, localRPCI->dependencyCount*sizeof(VkSubpassDependency));
         }
         renderPassMap[*pRenderPass] = localRPCI;
     }
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin *pRenderPassBegin)
+VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkRenderPassContents contents)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2571,11 +2621,12 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkR
                 updateCBTracking(cmdBuffer);
                 addCmd(pCB, CMD_BEGINRENDERPASS);
                 pCB->activeRenderPass = pRenderPassBegin->renderPass;
+                pCB->activeSubpass = 0;
                 pCB->framebuffer = pRenderPassBegin->framebuffer;
                 if (pCB->lastBoundPipeline) {
                     validatePipelineState(pCB, VK_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline);
                 }
-                get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
+                get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
             }
         } else {
             log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_INVALID_RENDERPASS, "DS",
@@ -2584,6 +2635,25 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkR
     }
 }
 
+VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents)
+{
+    GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
+    if (pCB) {
+        if (!pCB->activeRenderPass) {
+            log_msg(mdd(pCB->cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
+                    "Incorrect call to vkCmdNextSubpass() without an active RenderPass.");
+        } else {
+            updateCBTracking(cmdBuffer);
+            addCmd(pCB, CMD_NEXTSUBPASS);
+            pCB->activeSubpass++;
+            if (pCB->lastBoundPipeline) {
+                validatePipelineState(pCB, VK_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline);
+            }
+            get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdNextSubpass(cmdBuffer, contents);
+        }
+    }
+}
+
 VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
@@ -2595,6 +2665,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer)
             updateCBTracking(cmdBuffer);
             addCmd(pCB, CMD_ENDRENDERPASS);
             pCB->activeRenderPass = 0;
+            pCB->activeSubpass = 0;
             get_dispatch_table(draw_state_device_table_map, cmdBuffer)->CmdEndRenderPass(cmdBuffer);
         }
     }
@@ -2828,6 +2899,8 @@ VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcNa
         return (void*) vkCreateRenderPass;
     if (!strcmp(funcName, "vkCmdBeginRenderPass"))
         return (void*) vkCmdBeginRenderPass;
+    if (!strcmp(funcName, "vkCmdNextSubpass"))
+        return (void*) vkCmdNextSubpass;
     if (!strcmp(funcName, "vkCmdEndRenderPass"))
         return (void*) vkCmdEndRenderPass;
 
diff --git a/layers/draw_state.h b/layers/draw_state.h
index 6df743d1..dcebaa2e 100644
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -122,8 +122,8 @@ typedef struct _SAMPLER_NODE {
 typedef struct _IMAGE_NODE {
     union {
         VkImageViewCreateInfo ivci;
-        VkColorAttachmentViewCreateInfo cvci;
-        VkDepthStencilViewCreateInfo dsvci;
+        VkAttachmentViewCreateInfo cvci;
+        VkAttachmentViewCreateInfo dsvci;
     } createInfo;
 } IMAGE_NODE;
 
@@ -214,6 +214,7 @@ typedef enum _CMD_TYPE
     CMD_LOADATOMICCOUNTERS,
     CMD_SAVEATOMICCOUNTERS,
     CMD_BEGINRENDERPASS,
+    CMD_NEXTSUBPASS,
     CMD_ENDRENDERPASS,
     CMD_EXECUTECOMMANDS,
     CMD_DBGMARKERBEGIN,
@@ -264,6 +265,7 @@ typedef struct _GLOBAL_CB_NODE {
     VkDescriptorSet              lastBoundDescriptorSet;
     VkPipelineLayout             lastBoundPipelineLayout;
     VkRenderPass                 activeRenderPass;
+    uint32_t                     activeSubpass;
     VkFramebuffer                framebuffer;
     vector<VkDescriptorSet>      boundDescriptorSets;
 } GLOBAL_CB_NODE;
diff --git a/layers/image.cpp b/layers/image.cpp
index 53105673..224a5dd8 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -274,18 +274,18 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreat
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
 {
-    for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
+    for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
     {
-        if(pCreateInfo->pColorFormats[i] != VK_FORMAT_UNDEFINED)
+        if(pCreateInfo->pAttachments[i].format != VK_FORMAT_UNDEFINED)
         {
             layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
             VkFormatProperties properties;
             VkResult result = get_dispatch_table(image_instance_table_map, device_data->physicalDevice)->GetPhysicalDeviceFormatInfo(
-                    device_data->physicalDevice, pCreateInfo->pColorFormats[i], &properties);
+                    device_data->physicalDevice, pCreateInfo->pAttachments[i].format, &properties);
             if(result != VK_SUCCESS)
             {
                 std::stringstream ss;
-                ss << "vkCreateRenderPass parameter, VkFormat pCreateInfo->pColorFormats[" << i << "], cannot be validated";
+                ss << "vkCreateRenderPass parameter, VkFormat in pCreateInfo->pAttachments[" << i << "], cannot be validated";
                 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", ss.str().c_str());
                 continue;
             }
@@ -293,71 +293,43 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRende
             if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
             {
                 std::stringstream ss;
-                ss << "vkCreateRenderPass parameter, VkFormat pCreateInfo->pColorFormats[" << i << "], contains unsupported format";
+                ss << "vkCreateRenderPass parameter, VkFormat in pCreateInfo->pAttachments[" << i << "], contains unsupported format";
                 log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", ss.str().c_str());
             }
         }
     }
 
-    for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
+    for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
     {
-        if(!validate_VkImageLayout(pCreateInfo->pColorLayouts[i]))
+        if(!validate_VkImageLayout(pCreateInfo->pAttachments[i].initialLayout) ||
+           !validate_VkImageLayout(pCreateInfo->pAttachments[i].finalLayout))
         {
             std::stringstream ss;
-            ss << "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pColorLayouts[" << i << "], is unrecognized";
+            ss << "vkCreateRenderPass parameter, VkImageLayout in pCreateInfo->pAttachments[" << i << "], is unrecognized";
             log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", ss.str().c_str());
         }
     }
 
-    for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
+    for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
     {
-        if(!validate_VkAttachmentLoadOp(pCreateInfo->pColorLoadOps[i]))
+        if(!validate_VkAttachmentLoadOp(pCreateInfo->pAttachments[i].loadOp))
         {
             std::stringstream ss;
-            ss << "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->pColorLoadOps[" << i << "], is unrecognized";
+            ss << "vkCreateRenderPass parameter, VkAttachmentLoadOp in pCreateInfo->pAttachments[" << i << "], is unrecognized";
             log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", ss.str().c_str());
         }
     }
 
-    for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
+    for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
     {
-        if(!validate_VkAttachmentStoreOp(pCreateInfo->pColorStoreOps[i]))
+        if(!validate_VkAttachmentStoreOp(pCreateInfo->pAttachments[i].storeOp))
         {
             std::stringstream ss;
-            ss << "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->pColorStoreOps[" << i << "], is unrecognized";
+            ss << "vkCreateRenderPass parameter, VkAttachmentStoreOp in pCreateInfo->pAttachments[" << i << "], is unrecognized";
             log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", ss.str().c_str());
         }
     }
 
-    for(uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; ++i)
-    {
-        if(!vk_validate_vkclearcolorvalue(&(pCreateInfo->pColorLoadClearValues[i])))
-        {
-            std::stringstream ss;
-            ss << "vkCreateRenderPass parameter, VkClearColorValue pCreateInfo->pColorLoadClearValues[" << i << "], is invalid";
-            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", ss.str().c_str());
-        }
-    }
-
-    if(pCreateInfo->depthStencilFormat != VK_FORMAT_UNDEFINED)
-    {
-        layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-        VkFormatProperties properties;
-        VkResult result = get_dispatch_table(image_instance_table_map, device_data->physicalDevice)->GetPhysicalDeviceFormatInfo(
-                device_data->physicalDevice, pCreateInfo->depthStencilFormat, &properties);
-        if(result != VK_SUCCESS)
-        {
-            char const str[] = "vkCreateRenderPass parameter, VkFormat pCreateInfo->depthStencilFormat, cannot be validated";
-            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", str);
-        }
-
-        if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
-        {
-            char const str[] = "vkCreateRenderPass parameter, VkFormat pCreateInfo->depthStencilFormat, contains unsupported format";
-            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", str);
-        }
-    }
-
     VkResult result = get_dispatch_table(image_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
 
     return result;
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 22d6ef3f..0ae84f41 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1455,15 +1455,15 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(
+VK_LAYER_EXPORT VkResult VKAPI vkCreateAttachmentView(
     VkDevice                               device,
-    const VkColorAttachmentViewCreateInfo *pCreateInfo,
-    VkColorAttachmentView                 *pView)
+    const VkAttachmentViewCreateInfo *pCreateInfo,
+    VkAttachmentView                 *pView)
 {
-    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateColorAttachmentView(device, pCreateInfo, pView);
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateAttachmentView(device, pCreateInfo, pView);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkColorAttachmentViewCreateInfo), "color_attachment_view");
+        add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkAttachmentViewCreateInfo), "attachment_view");
         // Validate that img has correct usage flags set
         //  We don't use the image helper function here as it's a special case that checks struct type
         MT_OBJ_INFO* pInfo = get_object_info(pCreateInfo->image);
@@ -1481,23 +1481,6 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(
-    VkDevice                            device,
-    const VkDepthStencilViewCreateInfo *pCreateInfo,
-    VkDepthStencilView                 *pView)
-{
-    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDepthStencilView(device, pCreateInfo, pView);
-    if (result == VK_SUCCESS) {
-        loader_platform_thread_lock_mutex(&globalLock);
-        add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkDepthStencilViewCreateInfo), "ds_view");
-        // Validate that img has correct usage flags set
-        validate_image_usage_flags(device, pCreateInfo->image, VK_IMAGE_USAGE_DEPTH_STENCIL_BIT,
-                                   true, "vkCreateDepthStencilView()", "VK_IMAGE_USAGE_DEPTH_STENCIL_BIT");
-        loader_platform_thread_unlock_mutex(&globalLock);
-    }
-    return result;
-}
-
 VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
     VkDevice                  device,
     const VkShaderCreateInfo *pCreateInfo,
@@ -2244,10 +2227,8 @@ VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(
         return (void*) vkCreateImage;
     if (!strcmp(funcName, "vkCreateImageView"))
         return (void*) vkCreateImageView;
-    if (!strcmp(funcName, "vkCreateColorAttachmentView"))
-        return (void*) vkCreateColorAttachmentView;
-    if (!strcmp(funcName, "vkCreateDepthStencilView"))
-        return (void*) vkCreateDepthStencilView;
+    if (!strcmp(funcName, "vkCreateAttachmentView"))
+        return (void*) vkCreateAttachmentView;
     if (!strcmp(funcName, "vkCreateShader"))
         return (void*) vkCreateShader;
     if (!strcmp(funcName, "vkCreateGraphicsPipelines"))
diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h
index 3f6a0fef..f833c3a3 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -99,8 +99,7 @@ struct MT_OBJ_INFO {
     // The only objects that are guaranteed to have no external memory
     // requirements are devices, queues, command buffers, shaders and memory objects.
     union {
-        VkColorAttachmentViewCreateInfo    color_attachment_view_create_info;
-        VkDepthStencilViewCreateInfo       ds_view_create_info;
+        VkAttachmentViewCreateInfo         attachment_view_create_info;
         VkImageViewCreateInfo              image_view_create_info;
         VkImageCreateInfo                  image_create_info;
         VkGraphicsPipelineCreateInfo       graphics_pipeline_create_info;
@@ -118,8 +117,7 @@ struct MT_CB_INFO {
     VkCmdBufferCreateInfo       createInfo;
     MT_OBJ_INFO*                pDynamicState[VK_NUM_STATE_BIND_POINT];
     VkPipeline                  pipelines[VK_NUM_PIPELINE_BIND_POINT];
-    uint32_t                    colorAttachmentCount;
-    VkDepthStencilBindInfo      dsBindInfo;
+    uint32_t                    attachmentCount;
     VkCmdBuffer                 cmdBuffer;
     uint64_t                    fenceId;
     VkFence                     lastSubmittedFence;
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 3c3361d0..4658cfec 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -971,10 +971,10 @@ std::string EnumeratorString(VkImageCreateFlagBits const& enumerator)
 }
 
 static
-bool ValidateEnumerator(VkDepthStencilViewCreateFlagBits const& enumerator)
+bool ValidateEnumerator(VkAttachmentViewCreateFlagBits const& enumerator)
 {
-    VkDepthStencilViewCreateFlagBits allFlags = (VkDepthStencilViewCreateFlagBits)(VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT |
-        VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT);
+    VkAttachmentViewCreateFlagBits allFlags = (VkAttachmentViewCreateFlagBits)(VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT |
+        VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT);
     if(enumerator & (~allFlags))
     {
         return false;
@@ -984,7 +984,7 @@ bool ValidateEnumerator(VkDepthStencilViewCreateFlagBits const& enumerator)
 }
 
 static
-std::string EnumeratorString(VkDepthStencilViewCreateFlagBits const& enumerator)
+std::string EnumeratorString(VkAttachmentViewCreateFlagBits const& enumerator)
 {
     if(!ValidateEnumerator(enumerator))
     {
@@ -992,13 +992,13 @@ std::string EnumeratorString(VkDepthStencilViewCreateFlagBits const& enumerator)
     }
 
     std::vector<std::string> strings;
-    if(enumerator & VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT)
+    if(enumerator & VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT)
     {
-        strings.push_back("VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT");
+        strings.push_back("VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT");
     }
-    if(enumerator & VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT)
+    if(enumerator & VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT)
     {
-        strings.push_back("VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT");
+        strings.push_back("VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT");
     }
 
     std::string enumeratorString;
@@ -4295,184 +4295,93 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
     return result;
 }
 
-void PreCreateColorAttachmentView(
+void PreCreateAttachmentView(
     VkDevice device,
-    const VkColorAttachmentViewCreateInfo* pCreateInfo)
+    const VkAttachmentViewCreateInfo* pCreateInfo)
 {
     if(device == nullptr)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateColorAttachmentView parameter, VkDevice device, is null pointer");
+        "vkCreateAttachmentView parameter, VkDevice device, is null pointer");
         return;
     }
 
     if(pCreateInfo == nullptr)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateColorAttachmentView parameter, const VkColorAttachmentViewCreateInfo* pCreateInfo, is null pointer");
+        "vkCreateAttachmentView parameter, const VkAttachmentViewCreateInfo* pCreateInfo, is null pointer");
         return;
     }
     if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
         pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateColorAttachmentView parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
+        "vkCreateAttachmentView parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
         return;
     }
     if(pCreateInfo->image == nullptr)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateColorAttachmentView parameter, VkImage pCreateInfo->image, is null pointer");
+        "vkCreateAttachmentView parameter, VkImage pCreateInfo->image, is null pointer");
         return;
     }
     if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE ||
         pCreateInfo->format > VK_FORMAT_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateColorAttachmentView parameter, VkFormat pCreateInfo->format, is unrecognized enumerator");
+        "vkCreateAttachmentView parameter, VkFormat pCreateInfo->format, is unrecognized enumerator");
         return;
     }
-    if(pCreateInfo->msaaResolveImage == nullptr)
+    if(!ValidateEnumerator((VkAttachmentViewCreateFlagBits)pCreateInfo->flags))
     {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateColorAttachmentView parameter, VkImage pCreateInfo->msaaResolveImage, is null pointer");
-        return;
-    }
-    if(pCreateInfo->msaaResolveSubResource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
-        pCreateInfo->msaaResolveSubResource.aspect > VK_IMAGE_ASPECT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateColorAttachmentView parameter, VkImageAspect pCreateInfo->msaaResolveSubResource.aspect, is unrecognized enumerator");
-        return;
-    }
-}
-
-void PostCreateColorAttachmentView(
-    VkDevice device,
-    VkColorAttachmentView* pView,
-    VkResult result)
-{
-    if(device == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateColorAttachmentView parameter, VkDevice device, is null pointer");
-        return;
-    }
-
-    if(pView == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateColorAttachmentView parameter, VkColorAttachmentView* pView, is null pointer");
-        return;
-    }
-    if((*pView) == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateColorAttachmentView parameter, VkColorAttachmentView* pView, is null pointer");
-        return;
-    }
-
-    if(result != VK_SUCCESS)
-    {
-        std::string reason = "vkCreateColorAttachmentView parameter, VkResult result, is " + EnumeratorString(result);
+        std::string reason = "vkCreateAttachmentView parameter, VkAttachmentViewCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkAttachmentViewCreateFlagBits)pCreateInfo->flags);
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
         return;
     }
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(
+void PostCreateAttachmentView(
     VkDevice device,
-    const VkColorAttachmentViewCreateInfo* pCreateInfo,
-    VkColorAttachmentView* pView)
-{
-    PreCreateColorAttachmentView(device, pCreateInfo);
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateColorAttachmentView(device, pCreateInfo, pView);
-
-    PostCreateColorAttachmentView(device, pView, result);
-
-    return result;
-}
-
-void PreCreateDepthStencilView(
-    VkDevice device,
-    const VkDepthStencilViewCreateInfo* pCreateInfo)
-{
-    if(device == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateDepthStencilView parameter, VkDevice device, is null pointer");
-        return;
-    }
-
-    if(pCreateInfo == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateDepthStencilView parameter, const VkDepthStencilViewCreateInfo* pCreateInfo, is null pointer");
-        return;
-    }
-    if(pCreateInfo->sType < VK_STRUCTURE_TYPE_BEGIN_RANGE ||
-        pCreateInfo->sType > VK_STRUCTURE_TYPE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateDepthStencilView parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
-        return;
-    }
-    if(pCreateInfo->image == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateDepthStencilView parameter, VkImage pCreateInfo->image, is null pointer");
-        return;
-    }
-    if(!ValidateEnumerator((VkDepthStencilViewCreateFlagBits)pCreateInfo->flags))
-    {
-        std::string reason = "vkCreateDepthStencilView parameter, VkDepthStencilViewCreateFlags pCreateInfo->flags, is " + EnumeratorString((VkDepthStencilViewCreateFlagBits)pCreateInfo->flags);
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
-        return;
-    }
-}
-
-void PostCreateDepthStencilView(
-    VkDevice device,
-    VkDepthStencilView* pView,
+    VkAttachmentView* pView,
     VkResult result)
 {
     if(device == nullptr)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateDepthStencilView parameter, VkDevice device, is null pointer");
+        "vkCreateAttachmentView parameter, VkDevice device, is null pointer");
         return;
     }
 
     if(pView == nullptr)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateDepthStencilView parameter, VkDepthStencilView* pView, is null pointer");
+        "vkCreateAttachmentView parameter, VkAttachmentView* pView, is null pointer");
         return;
     }
     if((*pView) == nullptr)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateDepthStencilView parameter, VkDepthStencilView* pView, is null pointer");
+        "vkCreateAttachmentView parameter, VkAttachmentView* pView, is null pointer");
         return;
     }
 
     if(result != VK_SUCCESS)
     {
-        std::string reason = "vkCreateDepthStencilView parameter, VkResult result, is " + EnumeratorString(result);
+        std::string reason = "vkCreateAttachmentView parameter, VkResult result, is " + EnumeratorString(result);
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK", reason.c_str());
         return;
     }
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(
+VK_LAYER_EXPORT VkResult VKAPI vkCreateAttachmentView(
     VkDevice device,
-    const VkDepthStencilViewCreateInfo* pCreateInfo,
-    VkDepthStencilView* pView)
+    const VkAttachmentViewCreateInfo* pCreateInfo,
+    VkAttachmentView* pView)
 {
-    PreCreateDepthStencilView(device, pCreateInfo);
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDepthStencilView(device, pCreateInfo, pView);
+    PreCreateAttachmentView(device, pCreateInfo);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateAttachmentView(device, pCreateInfo, pView);
 
-    PostCreateDepthStencilView(device, pView, result);
+    PostCreateAttachmentView(device, pView, result);
 
     return result;
 }
@@ -4948,13 +4857,6 @@ void PreCreateGraphicsPipeline(
         "vkCreateGraphicsPipeline parameter, const void* pCreateInfo->pDsState->pNext, is null pointer");
         return;
     }
-    if(pCreateInfo->pDsState->format < VK_FORMAT_BEGIN_RANGE ||
-        pCreateInfo->pDsState->format > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipeline parameter, VkFormat pCreateInfo->pDsState->format, is unrecognized enumerator");
-        return;
-    }
     if(pCreateInfo->pDsState->depthCompareOp < VK_COMPARE_OP_BEGIN_RANGE ||
         pCreateInfo->pDsState->depthCompareOp > VK_COMPARE_OP_END_RANGE)
     {
@@ -5050,13 +4952,6 @@ void PreCreateGraphicsPipeline(
         "vkCreateGraphicsPipeline parameter, const VkPipelineCbAttachmentState* pCreateInfo->pCbState->pAttachments, is null pointer");
         return;
     }
-    if(pCreateInfo->pCbState->pAttachments->format < VK_FORMAT_BEGIN_RANGE ||
-        pCreateInfo->pCbState->pAttachments->format > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipeline parameter, VkFormat pCreateInfo->pCbState->pAttachments->format, is unrecognized enumerator");
-        return;
-    }
     if(pCreateInfo->pCbState->pAttachments->srcBlendColor < VK_BLEND_BEGIN_RANGE ||
         pCreateInfo->pCbState->pAttachments->srcBlendColor > VK_BLEND_END_RANGE)
     {
@@ -8379,42 +8274,23 @@ void PreCreateFramebuffer(
         "vkCreateFramebuffer parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
         return;
     }
-    if(pCreateInfo->pColorAttachments == nullptr)
+    if(pCreateInfo->pAttachments == nullptr)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateFramebuffer parameter, const VkColorAttachmentBindInfo* pCreateInfo->pColorAttachments, is null pointer");
+        "vkCreateFramebuffer parameter, const VkAttachmentBindInfo* pCreateInfo->pAttachments, is null pointer");
         return;
     }
-    if(pCreateInfo->pColorAttachments->view == nullptr)
+    if(pCreateInfo->pAttachments->view == nullptr)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateFramebuffer parameter, VkColorAttachmentView pCreateInfo->pColorAttachments->view, is null pointer");
+        "vkCreateFramebuffer parameter, VkAttachmentView pCreateInfo->pAttachments->view, is null pointer");
         return;
     }
-    if(pCreateInfo->pColorAttachments->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
-        pCreateInfo->pColorAttachments->layout > VK_IMAGE_LAYOUT_END_RANGE)
+    if(pCreateInfo->pAttachments->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
+        pCreateInfo->pAttachments->layout > VK_IMAGE_LAYOUT_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateFramebuffer parameter, VkImageLayout pCreateInfo->pColorAttachments->layout, is unrecognized enumerator");
-        return;
-    }
-    if(pCreateInfo->pDepthStencilAttachment == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateFramebuffer parameter, const VkDepthStencilBindInfo* pCreateInfo->pDepthStencilAttachment, is null pointer");
-        return;
-    }
-    if(pCreateInfo->pDepthStencilAttachment->view == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateFramebuffer parameter, VkDepthStencilView pCreateInfo->pDepthStencilAttachment->view, is null pointer");
-        return;
-    }
-    if(pCreateInfo->pDepthStencilAttachment->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
-        pCreateInfo->pDepthStencilAttachment->layout > VK_IMAGE_LAYOUT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateFramebuffer parameter, VkImageLayout pCreateInfo->pDepthStencilAttachment->layout, is unrecognized enumerator");
+        "vkCreateFramebuffer parameter, VkImageLayout pCreateInfo->pAttachments->layout, is unrecognized enumerator");
         return;
     }
 }
@@ -8469,6 +8345,8 @@ void PreCreateRenderPass(
     VkDevice device,
     const VkRenderPassCreateInfo* pCreateInfo)
 {
+    uint32_t i;
+
     if(device == nullptr)
     {
         log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
@@ -8489,105 +8367,48 @@ void PreCreateRenderPass(
         "vkCreateRenderPass parameter, VkStructureType pCreateInfo->sType, is unrecognized enumerator");
         return;
     }
-    if(pCreateInfo->pColorFormats == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, const VkFormat* pCreateInfo->pColorFormats, is null pointer");
-        return;
-    }
-    if((*pCreateInfo->pColorFormats) < VK_FORMAT_BEGIN_RANGE ||
-        (*pCreateInfo->pColorFormats) > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, const VkFormat* pCreateInfo->pColorFormats, is unrecognized enumerator");
-        return;
-    }
-    if(pCreateInfo->pColorLayouts == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, const VkImageLayout* pCreateInfo->pColorLayouts, is null pointer");
-        return;
-    }
-    if((*pCreateInfo->pColorLayouts) < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
-        (*pCreateInfo->pColorLayouts) > VK_IMAGE_LAYOUT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, const VkImageLayout* pCreateInfo->pColorLayouts, is unrecognized enumerator");
-        return;
-    }
-    if(pCreateInfo->pColorLoadOps == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, const VkAttachmentLoadOp* pCreateInfo->pColorLoadOps, is null pointer");
-        return;
-    }
-    if((*pCreateInfo->pColorLoadOps) < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
-        (*pCreateInfo->pColorLoadOps) > VK_ATTACHMENT_LOAD_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, const VkAttachmentLoadOp* pCreateInfo->pColorLoadOps, is unrecognized enumerator");
-        return;
-    }
-    if(pCreateInfo->pColorStoreOps == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, const VkAttachmentStoreOp* pCreateInfo->pColorStoreOps, is null pointer");
-        return;
-    }
-    if((*pCreateInfo->pColorStoreOps) < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
-        (*pCreateInfo->pColorStoreOps) > VK_ATTACHMENT_STORE_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, const VkAttachmentStoreOp* pCreateInfo->pColorStoreOps, is unrecognized enumerator");
-        return;
-    }
-    if(pCreateInfo->pColorLoadClearValues == nullptr)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, const VkClearColor* pCreateInfo->pColorLoadClearValues, is null pointer");
-        return;
-    }
-    if(pCreateInfo->depthStencilFormat < VK_FORMAT_BEGIN_RANGE ||
-        pCreateInfo->depthStencilFormat > VK_FORMAT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkFormat pCreateInfo->depthStencilFormat, is unrecognized enumerator");
-        return;
-    }
-    if(pCreateInfo->depthStencilLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE ||
-        pCreateInfo->depthStencilLayout > VK_IMAGE_LAYOUT_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->depthStencilLayout, is unrecognized enumerator");
-        return;
-    }
-    if(pCreateInfo->depthLoadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
-        pCreateInfo->depthLoadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->depthLoadOp, is unrecognized enumerator");
-        return;
-    }
-    if(pCreateInfo->depthStoreOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
-        pCreateInfo->depthStoreOp > VK_ATTACHMENT_STORE_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->depthStoreOp, is unrecognized enumerator");
-        return;
-    }
-    if(pCreateInfo->stencilLoadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE ||
-        pCreateInfo->stencilLoadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->stencilLoadOp, is unrecognized enumerator");
-        return;
-    }
-    if(pCreateInfo->stencilStoreOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE ||
-        pCreateInfo->stencilStoreOp > VK_ATTACHMENT_STORE_OP_END_RANGE)
+
+    for (i = 0; i < pCreateInfo->attachmentCount; i++)
     {
-        log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->stencilStoreOp, is unrecognized enumerator");
-        return;
+        const VkAttachmentDescription *att = &pCreateInfo->pAttachments[i];
+
+        if(att->format < VK_FORMAT_BEGIN_RANGE || att->format > VK_FORMAT_END_RANGE)
+        {
+            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
+            "vkCreateRenderPass parameter, VkFormat in pCreateInfo->pAttachments, is unrecognized enumerator");
+            return;
+        }
+        if(att->initialLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || att->initialLayout > VK_IMAGE_LAYOUT_END_RANGE ||
+           att->finalLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || att->finalLayout > VK_IMAGE_LAYOUT_END_RANGE)
+        {
+            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
+            "vkCreateRenderPass parameter, VkImageLayout in pCreateInfo->pAttachments, is unrecognized enumerator");
+            return;
+        }
+        if(att->loadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE || att->loadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE)
+        {
+            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
+            "vkCreateRenderPass parameter, VkAttachmentLoadOp in pCreateInfo->pAttachments, is unrecognized enumerator");
+            return;
+        }
+        if(att->storeOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE || att->storeOp > VK_ATTACHMENT_STORE_OP_END_RANGE)
+        {
+            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
+            "vkCreateRenderPass parameter, VkAttachmentStoreOp in pCreateInfo->pAttachments, is unrecognized enumerator");
+            return;
+        }
+        if(att->stencilLoadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE || att->stencilLoadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE)
+        {
+            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
+            "vkCreateRenderPass parameter, VkAttachmentLoadOp in pCreateInfo->pAttachments, is unrecognized enumerator");
+            return;
+        }
+        if(att->stencilStoreOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE || att->stencilStoreOp > VK_ATTACHMENT_STORE_OP_END_RANGE)
+        {
+            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
+            "vkCreateRenderPass parameter, VkAttachmentStoreOp in pCreateInfo->pAttachments, is unrecognized enumerator");
+            return;
+        }
     }
 }
 
@@ -8639,7 +8460,8 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
 
 void PreCmdBeginRenderPass(
     VkCmdBuffer cmdBuffer,
-    const VkRenderPassBegin* pRenderPassBegin)
+    const VkRenderPassBeginInfo* pRenderPassBegin,
+    VkRenderPassContents contents)
 {
     if(cmdBuffer == nullptr)
     {
@@ -8681,54 +8503,66 @@ void PostCmdBeginRenderPass(
 
 VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(
     VkCmdBuffer cmdBuffer,
-    const VkRenderPassBegin* pRenderPassBegin)
+    const VkRenderPassBeginInfo* pRenderPassBegin,
+    VkRenderPassContents contents)
 {
-    PreCmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
-    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
+    PreCmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
+    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
 
     PostCmdBeginRenderPass(cmdBuffer);
 }
 
-void PreCmdEndRenderPass(
-    VkCmdBuffer cmdBuffer)
+void PreCmdNextSubpass(
+    VkCmdBuffer cmdBuffer,
+    VkRenderPassContents contents)
 {
     if(cmdBuffer == nullptr)
     {
         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCmdEndRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
+        "vkCmdNextSubpass parameter, VkCmdBuffer cmdBuffer, is null pointer");
         return;
     }
 }
 
-void PostCmdEndRenderPass(
+void PostCmdNextSubpass(
     VkCmdBuffer cmdBuffer)
 {
     if(cmdBuffer == nullptr)
     {
         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCmdEndRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
+        "vkCmdNextSubpass parameter, VkCmdBuffer cmdBuffer, is null pointer");
         return;
     }
 }
 
-void PreCmdExecuteCommands(
+VK_LAYER_EXPORT void VKAPI vkCmdNextSubpass(
+    VkCmdBuffer cmdBuffer,
+    VkRenderPassContents contents)
+{
+    PreCmdNextSubpass(cmdBuffer, contents);
+    get_dispatch_table(pc_device_table_map, cmdBuffer)->CmdNextSubpass(cmdBuffer, contents);
+
+    PostCmdNextSubpass(cmdBuffer);
+}
+
+void PreCmdEndRenderPass(
     VkCmdBuffer cmdBuffer)
 {
     if(cmdBuffer == nullptr)
     {
         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCmdExecuteCommands parameter, VkCmdBuffer cmdBuffer, is null pointer");
+        "vkCmdEndRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
         return;
     }
 }
 
-void PostCmdExecuteCommands(
+void PostCmdEndRenderPass(
     VkCmdBuffer cmdBuffer)
 {
     if(cmdBuffer == nullptr)
     {
         log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkCmdExecuteCommands parameter, VkCmdBuffer cmdBuffer, is null pointer");
+        "vkCmdEndRenderPass parameter, VkCmdBuffer cmdBuffer, is null pointer");
         return;
     }
 }
@@ -8742,6 +8576,28 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(
     PostCmdEndRenderPass(cmdBuffer);
 }
 
+void PreCmdExecuteCommands(
+    VkCmdBuffer cmdBuffer)
+{
+    if(cmdBuffer == nullptr)
+    {
+        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
+        "vkCmdExecuteCommands parameter, VkCmdBuffer cmdBuffer, is null pointer");
+        return;
+    }
+}
+
+void PostCmdExecuteCommands(
+    VkCmdBuffer cmdBuffer)
+{
+    if(cmdBuffer == nullptr)
+    {
+        log_msg(mdd(cmdBuffer), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
+        "vkCmdExecuteCommands parameter, VkCmdBuffer cmdBuffer, is null pointer");
+        return;
+    }
+}
+
 VK_LAYER_EXPORT void VKAPI vkCmdExecuteCommands(
     VkCmdBuffer                                 cmdBuffer,
     uint32_t                                    cmdBuffersCount,
@@ -8829,10 +8685,8 @@ VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* fun
         return (void*) vkGetImageSubresourceLayout;
     if (!strcmp(funcName, "vkCreateImageView"))
         return (void*) vkCreateImageView;
-    if (!strcmp(funcName, "vkCreateColorAttachmentView"))
-        return (void*) vkCreateColorAttachmentView;
-    if (!strcmp(funcName, "vkCreateDepthStencilView"))
-        return (void*) vkCreateDepthStencilView;
+    if (!strcmp(funcName, "vkCreateAttachmentView"))
+        return (void*) vkCreateAttachmentView;
     if (!strcmp(funcName, "vkCreateShader"))
         return (void*) vkCreateShader;
     if (!strcmp(funcName, "vkCreateGraphicsPipelines"))
@@ -8933,6 +8787,8 @@ VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* fun
         return (void*) vkCreateRenderPass;
     if (!strcmp(funcName, "vkCmdBeginRenderPass"))
         return (void*) vkCmdBeginRenderPass;
+    if (!strcmp(funcName, "vkCmdNextSubpass"))
+        return (void*) vkCmdNextSubpass;
     if (!strcmp(funcName, "vkCmdEndRenderPass"))
         return (void*) vkCmdEndRenderPass;
 
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 8d1a865f..23b0c103 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -171,6 +171,33 @@ struct shader_object {
 };
 static std::unordered_map<void *, shader_object *> shader_object_map;
 
+struct render_pass {
+    std::vector<std::vector<VkFormat>> subpass_color_formats;
+
+    render_pass(VkRenderPassCreateInfo const *pCreateInfo)
+    {
+        uint32_t i;
+
+        subpass_color_formats.reserve(pCreateInfo->subpassCount);
+        for (i = 0; i < pCreateInfo->subpassCount; i++) {
+            const VkSubpassDescription *subpass = &pCreateInfo->pSubpasses[i];
+            std::vector<VkFormat> color_formats;
+            uint32_t j;
+
+            color_formats.reserve(subpass->colorCount);
+            for (j = 0; j < subpass->colorCount; j++) {
+                const uint32_t att = subpass->colorAttachments[j].attachment;
+                const VkFormat format = pCreateInfo->pAttachments[att].format;
+
+                color_formats.push_back(pCreateInfo->pAttachments[att].format);
+            }
+
+            subpass_color_formats.push_back(color_formats);
+        }
+    }
+};
+static std::unordered_map<void *, render_pass *> render_pass_map;
+
 
 static void
 init_shader_checker(layer_data *my_data)
@@ -519,6 +546,19 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
     return res;
 }
 
+VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
+        VkDevice device,
+        const VkRenderPassCreateInfo *pCreateInfo,
+        VkRenderPass *pRenderPass)
+{
+    loader_platform_thread_lock_mutex(&globalLock);
+    VkResult res = get_dispatch_table(shader_checker_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
+
+    render_pass_map[(VkBaseLayerObject *) *pRenderPass] = new render_pass(pCreateInfo);
+    loader_platform_thread_unlock_mutex(&globalLock);
+    return res;
+}
+
 static bool
 validate_interface_between_stages(VkDevice dev,
                                   shader_module const *producer, char const *producer_name,
@@ -755,8 +795,9 @@ validate_vi_against_vs_inputs(VkDevice dev, VkPipelineVertexInputStateCreateInfo
 
 
 static bool
-validate_fs_outputs_against_cb(VkDevice dev, shader_module const *fs, VkPipelineCbStateCreateInfo const *cb)
+validate_fs_outputs_against_render_pass(VkDevice dev, shader_module const *fs, render_pass const *rp, uint32_t subpass)
 {
+    const std::vector<VkFormat> &color_formats = rp->subpass_color_formats[subpass];
     std::map<uint32_t, interface_var> outputs;
     std::map<uint32_t, interface_var> builtin_outputs;
     bool pass = true;
@@ -775,8 +816,8 @@ validate_fs_outputs_against_cb(VkDevice dev, shader_module const *fs, VkPipeline
             pass = false;
         }
 
-        for (unsigned i = 0; i < cb->attachmentCount; i++) {
-            unsigned attachmentType = get_format_type(cb->pAttachments[i].format);
+        for (unsigned i = 0; i < color_formats.size(); i++) {
+            unsigned attachmentType = get_format_type(color_formats[i]);
             if (attachmentType == FORMAT_TYPE_SINT || attachmentType == FORMAT_TYPE_UINT) {
                 log_msg(mdd(dev), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC",
                         "CB format should not be SINT or UINT when using broadcast");
@@ -794,8 +835,8 @@ validate_fs_outputs_against_cb(VkDevice dev, shader_module const *fs, VkPipeline
      * are currently dense, but the parallel with matching between shader stages is nice.
      */
 
-    while ((outputs.size() > 0 && it != outputs.end()) || attachment < cb->attachmentCount) {
-        if (attachment == cb->attachmentCount || ( it != outputs.end() && it->first < attachment)) {
+    while ((outputs.size() > 0 && it != outputs.end()) || attachment < color_formats.size()) {
+        if (attachment == color_formats.size() || ( it != outputs.end() && it->first < attachment)) {
             log_msg(mdd(dev), VK_DBG_REPORT_WARN_BIT, (VkObjectType) 0, NULL, 0, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC",
                     "FS writes to output location %d with no matching attachment", it->first);
             it++;
@@ -808,7 +849,7 @@ validate_fs_outputs_against_cb(VkDevice dev, shader_module const *fs, VkPipeline
         }
         else {
             unsigned output_type = get_fundamental_type(fs, it->second.type_id);
-            unsigned att_type = get_format_type(cb->pAttachments[attachment].format);
+            unsigned att_type = get_format_type(color_formats[attachment]);
 
             /* type checking */
             if (att_type != FORMAT_TYPE_UNDEFINED && output_type != FORMAT_TYPE_UNDEFINED && att_type != output_type) {
@@ -816,7 +857,7 @@ validate_fs_outputs_against_cb(VkDevice dev, shader_module const *fs, VkPipeline
                 describe_type(fs_type, fs, it->second.type_id);
                 log_msg(mdd(dev), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, NULL, 0, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC",
                         "Attachment %d of type `%s` does not match FS output type of `%s`",
-                        attachment, string_VkFormat(cb->pAttachments[attachment].format), fs_type);
+                        attachment, string_VkFormat(color_formats[attachment]), fs_type);
                 pass = false;
             }
 
@@ -855,7 +896,7 @@ validate_graphics_pipeline(VkDevice dev, uint32_t count, VkGraphicsPipelineCreat
 
     shader_module const *shaders[VK_SHADER_STAGE_FRAGMENT + 1];  /* exclude CS */
     memset(shaders, 0, sizeof(shaders));
-    VkPipelineCbStateCreateInfo const *cb = 0;
+    render_pass const *rp = 0;
     VkPipelineVertexInputStateCreateInfo const *vi = 0;
     bool pass = true;
 
@@ -876,7 +917,9 @@ validate_graphics_pipeline(VkDevice dev, uint32_t count, VkGraphicsPipelineCreat
         }
     }
 
-    cb = pCreateInfo->pCbState;
+    if (pCreateInfo->renderPass != VK_NULL_HANDLE)
+        rp = render_pass_map[(void *) pCreateInfo->renderPass];
+
     vi = pCreateInfo->pVertexInputState;
 
     if (vi) {
@@ -910,8 +953,8 @@ validate_graphics_pipeline(VkDevice dev, uint32_t count, VkGraphicsPipelineCreat
         }
     }
 
-    if (shaders[VK_SHADER_STAGE_FRAGMENT] && shaders[VK_SHADER_STAGE_FRAGMENT]->is_spirv && cb) {
-        pass = validate_fs_outputs_against_cb(dev, shaders[VK_SHADER_STAGE_FRAGMENT], cb) && pass;
+    if (shaders[VK_SHADER_STAGE_FRAGMENT] && shaders[VK_SHADER_STAGE_FRAGMENT]->is_spirv && rp) {
+        pass = validate_fs_outputs_against_render_pass(dev, shaders[VK_SHADER_STAGE_FRAGMENT], rp, pCreateInfo->subpass) && pass;
     }
 
     loader_platform_thread_unlock_mutex(&globalLock);
@@ -1048,6 +1091,7 @@ VK_LAYER_EXPORT void * VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcN
     ADD_HOOK(vkCreateDevice);
     ADD_HOOK(vkCreateShaderModule);
     ADD_HOOK(vkCreateShader);
+    ADD_HOOK(vkCreateRenderPass);
     ADD_HOOK(vkDestroyDevice);
     ADD_HOOK(vkCreateGraphicsPipelines);
 #undef ADD_HOOK
diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index 9532d5d2..6da2fcc4 100644
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -141,10 +141,8 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkGetImageSubresourceLayout;
     if (!strcmp(name, "CreateImageView"))
         return (void*) vkCreateImageView;
-    if (!strcmp(name, "CreateColorAttachmentView"))
-        return (void*) vkCreateColorAttachmentView;
-    if (!strcmp(name, "CreateDepthStencilView"))
-        return (void*) vkCreateDepthStencilView;
+    if (!strcmp(name, "CreateAttachmentView"))
+        return (void*) vkCreateAttachmentView;
     if (!strcmp(name, "CreateShaderModule"))
         return (void*) vkCreateShaderModule;
     if (!strcmp(name, "CreateShader"))
@@ -263,6 +261,8 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkCreateRenderPass;
     if (!strcmp(name, "CmdBeginRenderPass"))
         return (void*) vkCmdBeginRenderPass;
+    if (!strcmp(name, "CmdNextSubpass"))
+        return (void*) vkCmdNextSubpass;
     if (!strcmp(name, "CmdEndRenderPass"))
         return (void*) vkCmdEndRenderPass;
 
diff --git a/loader/table_ops.h b/loader/table_ops.h
index 7563af84..d6ddbfce 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -74,8 +74,7 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     table->CreateImage = (PFN_vkCreateImage) gpa(dev, "vkCreateImage");
     table->GetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout) gpa(dev, "vkGetImageSubresourceLayout");
     table->CreateImageView = (PFN_vkCreateImageView) gpa(dev, "vkCreateImageView");
-    table->CreateColorAttachmentView = (PFN_vkCreateColorAttachmentView) gpa(dev, "vkCreateColorAttachmentView");
-    table->CreateDepthStencilView = (PFN_vkCreateDepthStencilView) gpa(dev, "vkCreateDepthStencilView");
+    table->CreateAttachmentView = (PFN_vkCreateAttachmentView) gpa(dev, "vkCreateAttachmentView");
     table->CreateShaderModule = (PFN_vkCreateShaderModule) gpa(dev, "vkCreateShaderModule");
     table->CreateShader = (PFN_vkCreateShader) gpa(dev, "vkCreateShader");
     table->CreatePipelineCache = (PFN_vkCreatePipelineCache) gpa(dev, "vkCreatePipelineCache");
@@ -135,6 +134,7 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     table->CreateFramebuffer = (PFN_vkCreateFramebuffer) gpa(dev, "vkCreateFramebuffer");
     table->CreateRenderPass = (PFN_vkCreateRenderPass) gpa(dev, "vkCreateRenderPass");
     table->CmdBeginRenderPass = (PFN_vkCmdBeginRenderPass) gpa(dev, "vkCmdBeginRenderPass");
+    table->CmdNextSubpass = (PFN_vkCmdNextSubpass) gpa(dev, "vkCmdNextSubpass");
     table->CmdEndRenderPass = (PFN_vkCmdEndRenderPass) gpa(dev, "vkCmdEndRenderPass");
     table->CmdExecuteCommands = (PFN_vkCmdExecuteCommands) gpa(dev, "vkCmdExecuteCommands");
 //TODO move into it's own table
@@ -230,10 +230,8 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->GetImageSubresourceLayout;
     if (!strcmp(name, "CreateImageView"))
         return (void *) table->CreateImageView;
-    if (!strcmp(name, "CreateColorAttachmentView"))
-        return (void *) table->CreateColorAttachmentView;
-    if (!strcmp(name, "CreateDepthStencilView"))
-        return (void *) table->CreateDepthStencilView;
+    if (!strcmp(name, "CreateAttachmentView"))
+        return (void *) table->CreateAttachmentView;
     if (!strcmp(name, "CreateShaderModule"))
         return (void *) table->CreateShaderModule;
     if (!strcmp(name, "CreateShader"))
@@ -352,6 +350,8 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->CreateRenderPass;
     if (!strcmp(name, "CmdBeginRenderPass"))
         return (void *) table->CmdBeginRenderPass;
+    if (!strcmp(name, "CmdNextSubpass"))
+        return (void *) table->CmdNextSubpass;
     if (!strcmp(name, "CmdEndRenderPass"))
         return (void *) table->CmdEndRenderPass;
 
diff --git a/loader/trampoline.c b/loader/trampoline.c
index ebf4f5de..baa7bd1f 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -654,22 +654,13 @@ LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageVie
     return disp->CreateImageView(device, pCreateInfo, pView);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView)
+LOADER_EXPORT VkResult VKAPI vkCreateAttachmentView(VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateColorAttachmentView(device, pCreateInfo, pView);
-}
-
-LOADER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView)
-{
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateDepthStencilView(device, pCreateInfo, pView);
+    return disp->CreateAttachmentView(device, pCreateInfo, pView);
 }
 
 LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShader)
@@ -1200,13 +1191,22 @@ LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderP
     return disp->CreateRenderPass(device, pCreateInfo, pRenderPass);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin)
+LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
+}
+
+LOADER_EXPORT void VKAPI vkCmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
+    disp->CmdNextSubpass(cmdBuffer, contents);
 }
 
 LOADER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer)
diff --git a/vulkan.py b/vulkan.py
index 2415f3ba..123fccf4 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -194,8 +194,7 @@ core = Extension(
         "VkBufferView",
         "VkImage",
         "VkImageView",
-        "VkColorAttachmentView",
-        "VkDepthStencilView",
+        "VkAttachmentView",
         "VkShader",
         "VkPipeline",
         "VkPipelineCache",
@@ -493,15 +492,10 @@ core = Extension(
              Param("const VkImageViewCreateInfo*", "pCreateInfo"),
              Param("VkImageView*", "pView")]),
 
-        Proto("VkResult", "CreateColorAttachmentView",
+        Proto("VkResult", "CreateAttachmentView",
             [Param("VkDevice", "device"),
-             Param("const VkColorAttachmentViewCreateInfo*", "pCreateInfo"),
-             Param("VkColorAttachmentView*", "pView")]),
-
-        Proto("VkResult", "CreateDepthStencilView",
-            [Param("VkDevice", "device"),
-             Param("const VkDepthStencilViewCreateInfo*", "pCreateInfo"),
-             Param("VkDepthStencilView*", "pView")]),
+             Param("const VkAttachmentViewCreateInfo*", "pCreateInfo"),
+             Param("VkAttachmentView*", "pView")]),
 
         Proto("VkResult", "CreateShaderModule",
             [Param("VkDevice", "device"),
@@ -873,7 +867,12 @@ core = Extension(
 
         Proto("void", "CmdBeginRenderPass",
             [Param("VkCmdBuffer", "cmdBuffer"),
-             Param("const VkRenderPassBegin*", "pRenderPassBegin")]),
+             Param("const VkRenderPassBeginInfo*", "pRenderPassBegin"),
+             Param("VkRenderPassContents", "contents")]),
+
+        Proto("void", "CmdNextSubpass",
+            [Param("VkCmdBuffer", "cmdBuffer"),
+             Param("VkRenderPassContents", "contents")]),
 
         Proto("void", "CmdEndRenderPass",
             [Param("VkCmdBuffer", "cmdBuffer")]),
@@ -942,8 +941,7 @@ object_list = [
     "VkBufferView",
     "VkImage",
     "VkImageView",
-    "VkColorAttachmentView",
-    "VkDepthStencilView",
+    "VkAttachmentView",
     "VkShader",
     "VkPipeline",
     "VkPipelineCache",