diff --git a/demos/cube.c b/demos/cube.c
index 6f2d24c..426b712 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -207,6 +207,7 @@
     uint32_t graphics_queue_node_index;
     XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *queue_props;
 
+    XGL_FRAMEBUFFER framebuffer;
     int width, height;
     XGL_FORMAT format;
 
@@ -280,13 +281,9 @@
     };
     const float clear_depth = 1.0f;
     XGL_IMAGE_SUBRESOURCE_RANGE clear_range;
-    XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO graphics_cmd_buf_info = {
-        .sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO,
-        .pNext = NULL,
-    };
     XGL_CMD_BUFFER_BEGIN_INFO cmd_buf_info = {
         .sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
-        .pNext = &graphics_cmd_buf_info,
+        .pNext = NULL,
         .flags = XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT |
             XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT,
     };
@@ -305,22 +302,29 @@
          .layers = 1,
     };
     XGL_RENDER_PASS_CREATE_INFO rp_info;
+    XGL_RENDER_PASS_BEGIN rp_begin;
 
     memset(&rp_info, 0 , sizeof(rp_info));
-    err = xglCreateFramebuffer(demo->device, &fb_info, &(rp_info.framebuffer));
+    err = xglCreateFramebuffer(demo->device, &fb_info, &rp_begin.framebuffer);
     assert(!err);
     rp_info.sType = XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
     rp_info.renderArea.extent.width = demo->width;
     rp_info.renderArea.extent.height = demo->height;
-    rp_info.colorAttachmentCount = 1;
-    rp_info.pColorLoadClearValues = &clear_color;
+    rp_info.colorAttachmentCount = fb_info.colorAttachmentCount;
+    rp_info.pColorFormats = &demo->format;
+    rp_info.pColorLayouts = &color_attachment.layout;
     rp_info.pColorLoadOps = &load_op;
     rp_info.pColorStoreOps = &store_op;
+    rp_info.pColorLoadClearValues = &clear_color;
+    rp_info.depthStencilFormat = XGL_FMT_D16_UNORM;
+    rp_info.depthStencilLayout = depth_stencil.layout;
     rp_info.depthLoadOp = XGL_ATTACHMENT_LOAD_OP_DONT_CARE;
+    rp_info.depthLoadClearValue = clear_depth;
     rp_info.depthStoreOp = XGL_ATTACHMENT_STORE_OP_DONT_CARE;
     rp_info.stencilLoadOp = XGL_ATTACHMENT_LOAD_OP_DONT_CARE;
+    rp_info.stencilLoadClearValue = 0;
     rp_info.stencilStoreOp = XGL_ATTACHMENT_STORE_OP_DONT_CARE;
-    err = xglCreateRenderPass(demo->device, &rp_info, &(graphics_cmd_buf_info.renderPass));
+    err = xglCreateRenderPass(demo->device, &rp_info, &rp_begin.renderPass);
     assert(!err);
 
     err = xglBeginCommandBuffer(cmd_buf, &cmd_buf_info);
@@ -338,7 +342,7 @@
     xglCmdBindDynamicStateObject(cmd_buf, XGL_STATE_BIND_DEPTH_STENCIL,
                                      demo->depth_stencil);
 
-    xglCmdBeginRenderPass(cmd_buf, graphics_cmd_buf_info.renderPass);
+    xglCmdBeginRenderPass(cmd_buf, &rp_begin);
     clear_range.aspect = XGL_IMAGE_ASPECT_COLOR;
     clear_range.baseMipLevel = 0;
     clear_range.mipLevels = 1;
@@ -353,13 +357,13 @@
             clear_depth, 0, 1, &clear_range);
 
     xglCmdDraw(cmd_buf, 0, 12 * 3, 0, 1);
-    xglCmdEndRenderPass(cmd_buf, graphics_cmd_buf_info.renderPass);
+    xglCmdEndRenderPass(cmd_buf, rp_begin.renderPass);
 
     err = xglEndCommandBuffer(cmd_buf);
     assert(!err);
 
-    xglDestroyObject(graphics_cmd_buf_info.renderPass);
-    xglDestroyObject(rp_info.framebuffer);
+    xglDestroyObject(rp_begin.renderPass);
+    xglDestroyObject(rp_begin.framebuffer);
 }
 
 
diff --git a/demos/tri.c b/demos/tri.c
index d3a0377..43824b6 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -110,13 +110,9 @@
     };
     const float clear_depth = 0.9f;
     XGL_IMAGE_SUBRESOURCE_RANGE clear_range;
-    XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO graphics_cmd_buf_info = {
-        .sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO,
-        .pNext = NULL,
-    };
     XGL_CMD_BUFFER_BEGIN_INFO cmd_buf_info = {
         .sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
-        .pNext = &graphics_cmd_buf_info,
+        .pNext = NULL,
         .flags = XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT |
             XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT,
     };
@@ -135,21 +131,29 @@
          .layers = 1,
     };
     XGL_RENDER_PASS_CREATE_INFO rp_info;
+    XGL_RENDER_PASS_BEGIN rp_begin;
 
     memset(&rp_info, 0 , sizeof(rp_info));
-    err = xglCreateFramebuffer(demo->device, &fb_info, &(rp_info.framebuffer));
+    err = xglCreateFramebuffer(demo->device, &fb_info, &rp_begin.framebuffer);
     assert(!err);
     rp_info.sType = XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
     rp_info.renderArea.extent.width = demo->width;
     rp_info.renderArea.extent.height = demo->height;
     rp_info.colorAttachmentCount = fb_info.colorAttachmentCount;
+    rp_info.pColorFormats = &demo->format;
+    rp_info.pColorLayouts = &color_attachment.layout;
     rp_info.pColorLoadOps = &load_op;
     rp_info.pColorStoreOps = &store_op;
+    rp_info.pColorLoadClearValues = &clear_color;
+    rp_info.depthStencilFormat = XGL_FMT_D16_UNORM;
+    rp_info.depthStencilLayout = depth_stencil.layout;
     rp_info.depthLoadOp = XGL_ATTACHMENT_LOAD_OP_DONT_CARE;
+    rp_info.depthLoadClearValue = clear_depth;
     rp_info.depthStoreOp = XGL_ATTACHMENT_STORE_OP_DONT_CARE;
     rp_info.stencilLoadOp = XGL_ATTACHMENT_LOAD_OP_DONT_CARE;
+    rp_info.stencilLoadClearValue = 0;
     rp_info.stencilStoreOp = XGL_ATTACHMENT_STORE_OP_DONT_CARE;
-    err = xglCreateRenderPass(demo->device, &rp_info, &(graphics_cmd_buf_info.renderPass));
+    err = xglCreateRenderPass(demo->device, &rp_info, &(rp_begin.renderPass));
     assert(!err);
 
     err = xglBeginCommandBuffer(demo->cmd, &cmd_buf_info);
@@ -170,7 +174,7 @@
 
     xglCmdBindVertexBuffer(demo->cmd, demo->vertices.buf, 0, 0);
 
-    xglCmdBeginRenderPass(demo->cmd, graphics_cmd_buf_info.renderPass);
+    xglCmdBeginRenderPass(demo->cmd, &rp_begin);
     clear_range.aspect = XGL_IMAGE_ASPECT_COLOR;
     clear_range.baseMipLevel = 0;
     clear_range.mipLevels = 1;
@@ -185,13 +189,13 @@
             clear_depth, 0, 1, &clear_range);
 
     xglCmdDraw(demo->cmd, 0, 3, 0, 1);
-    xglCmdEndRenderPass(demo->cmd, graphics_cmd_buf_info.renderPass);
+    xglCmdEndRenderPass(demo->cmd, rp_begin.renderPass);
 
     err = xglEndCommandBuffer(demo->cmd);
     assert(!err);
 
-    xglDestroyObject(graphics_cmd_buf_info.renderPass);
-    xglDestroyObject(rp_info.framebuffer);
+    xglDestroyObject(rp_begin.renderPass);
+    xglDestroyObject(rp_begin.framebuffer);
 }
 
 static void demo_draw(struct demo *demo)
diff --git a/icd/intel/cmd.c b/icd/intel/cmd.c
index a5d7b7a..d4f6a7a 100644
--- a/icd/intel/cmd.c
+++ b/icd/intel/cmd.c
@@ -321,7 +321,8 @@
             break;
         case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
             ginfo = (const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *) info;
-            cmd_begin_render_pass(cmd, intel_render_pass(ginfo->renderPass));
+            cmd_begin_render_pass(cmd, intel_render_pass(ginfo->renderPassContinue.renderPass),
+                                  intel_fb(ginfo->renderPassContinue.framebuffer));
             break;
         default:
             return XGL_ERROR_INVALID_VALUE;
diff --git a/icd/intel/cmd.h b/icd/intel/cmd.h
index 263fea6..209e7f8 100644
--- a/icd/intel/cmd.h
+++ b/icd/intel/cmd.h
@@ -185,8 +185,9 @@
     } index;
 
 
-    const struct intel_render_pass *render_pass;
     bool render_pass_changed;
+    const struct intel_render_pass *render_pass;
+    const struct intel_fb *fb;
 
     uint32_t draw_count;
     uint32_t wa_flags;
diff --git a/icd/intel/cmd_pipeline.c b/icd/intel/cmd_pipeline.c
index de2adfd..00851e5 100644
--- a/icd/intel/cmd_pipeline.c
+++ b/icd/intel/cmd_pipeline.c
@@ -399,7 +399,7 @@
             format = GEN6_ZFORMAT_D32_FLOAT;
             break;
         default:
-            assert(!cmd->bind.render_pass->fb->ds); // Must have valid format if ds attached
+            assert(!cmd->bind.fb->ds); // Must have valid format if ds attached
             format = 0;
             break;
         }
@@ -526,7 +526,7 @@
           (viewport->viewport_count - 1);
 
     /* TODO: framebuffer requests layer_count > 1 */
-    if (cmd->bind.render_pass->fb->array_size == 1) {
+    if (cmd->bind.fb->array_size == 1) {
         dw3 |= GEN6_CLIP_DW3_RTAINDEX_FORCED_ZERO;
     }
 
@@ -1660,8 +1660,8 @@
         case INTEL_PIPELINE_RMAP_RT:
             {
                 const struct intel_rt_view *view =
-                    (slot->u.rt < cmd->bind.render_pass->fb->rt_count) ?
-                    cmd->bind.render_pass->fb->rt[slot->u.rt] : NULL;
+                    (slot->u.rt < cmd->bind.fb->rt_count) ?
+                    cmd->bind.fb->rt[slot->u.rt] : NULL;
 
                 if (view) {
                     offset = cmd_surface_write(cmd, INTEL_CMD_ITEM_SURFACE,
@@ -1931,7 +1931,7 @@
 
 static void emit_msaa(struct intel_cmd *cmd)
 {
-    const struct intel_fb *fb = cmd->bind.render_pass->fb;
+    const struct intel_fb *fb = cmd->bind.fb;
 
     if (!cmd->bind.render_pass_changed)
         return;
@@ -1945,18 +1945,19 @@
 
 static void emit_rt(struct intel_cmd *cmd)
 {
-    const struct intel_fb *fb = cmd->bind.render_pass->fb;
+    const struct intel_fb *fb = cmd->bind.fb;
 
     if (!cmd->bind.render_pass_changed)
         return;
 
     cmd_wa_gen6_pre_depth_stall_write(cmd);
-    gen6_3DSTATE_DRAWING_RECTANGLE(cmd, fb->width, fb->height);
+    gen6_3DSTATE_DRAWING_RECTANGLE(cmd, fb->width,
+            fb->height);
 }
 
 static void emit_ds(struct intel_cmd *cmd)
 {
-    const struct intel_fb *fb = cmd->bind.render_pass->fb;
+    const struct intel_fb *fb = cmd->bind.fb;
     const struct intel_ds_view *ds = fb->ds;
 
     if (!cmd->bind.render_pass_changed)
@@ -3502,11 +3503,11 @@
 
 ICD_EXPORT void XGLAPI xglCmdBeginRenderPass(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_RENDER_PASS                             renderPass)
+    const XGL_RENDER_PASS_BEGIN*                pRenderPassBegin)
 {
    struct intel_cmd *cmd = intel_cmd(cmdBuffer);
 
-   cmd_begin_render_pass(cmd, (struct intel_render_pass *) renderPass);
+   cmd_begin_render_pass(cmd, (struct intel_render_pass *) pRenderPassBegin->renderPass, pRenderPassBegin->framebuffer);
 }
 
 ICD_EXPORT void XGLAPI xglCmdEndRenderPass(
diff --git a/icd/intel/cmd_priv.h b/icd/intel/cmd_priv.h
index e396d12..ff930a9 100644
--- a/icd/intel/cmd_priv.h
+++ b/icd/intel/cmd_priv.h
@@ -485,10 +485,12 @@
 }
 
 static inline void cmd_begin_render_pass(struct intel_cmd *cmd,
-                                         const struct intel_render_pass *rp)
+                                         const struct intel_render_pass *rp,
+                                         const struct intel_fb *fb)
 {
     cmd->bind.render_pass = rp;
     cmd->bind.render_pass_changed = true;
+    cmd->bind.fb = fb;
 }
 
 static inline void cmd_end_render_pass(struct intel_cmd *cmd,
@@ -496,6 +498,7 @@
 {
     //note what to do if rp != bound rp
     cmd->bind.render_pass = 0;
+    cmd->bind.fb = 0;
 }
 
 void cmd_batch_flush(struct intel_cmd *cmd, uint32_t pipe_control_dw0);
diff --git a/icd/intel/fb.c b/icd/intel/fb.c
index 845ecae..56d2dde 100644
--- a/icd/intel/fb.c
+++ b/icd/intel/fb.c
@@ -152,8 +152,6 @@
 
     rp->obj.destroy = render_pass_destroy;
 
-    rp->fb = intel_fb(info->framebuffer);
-
     /* TODO add any clear color ops */
     for (i = 0; i < info->colorAttachmentCount; i++)
         assert(info->pColorLoadOps[i] != XGL_ATTACHMENT_LOAD_OP_CLEAR);
@@ -167,8 +165,6 @@
 
 void intel_render_pass_destroy(struct intel_render_pass *rp)
 {
-    rp->fb = NULL;
-
     intel_base_destroy(&rp->obj.base);
 }
 
diff --git a/icd/intel/fb.h b/icd/intel/fb.h
index f7c6b1f..873f49d 100644
--- a/icd/intel/fb.h
+++ b/icd/intel/fb.h
@@ -46,8 +46,6 @@
 
 struct intel_render_pass {
     struct intel_obj obj;
-
-    struct intel_fb *fb;
 };
 
 static inline struct intel_fb *intel_fb(XGL_FRAMEBUFFER fb)
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index f6fa9e0..2db8f64 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -1995,7 +1995,7 @@
 
 ICD_EXPORT void XGLAPI xglCmdBeginRenderPass(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_RENDER_PASS                             renderPass)
+    const XGL_RENDER_PASS_BEGIN*                pRenderPassBegin)
 {
     NULLDRV_LOG_FUNC;
 }
diff --git a/include/xgl.h b/include/xgl.h
index bffc7df..1955f8a 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -33,7 +33,7 @@
 #include "xglPlatform.h"
 
 // XGL API version supported by this file
-#define XGL_API_VERSION XGL_MAKE_VERSION(0, 56, 1)
+#define XGL_API_VERSION XGL_MAKE_VERSION(0, 57, 1)
 
 #ifdef __cplusplus
 extern "C"
@@ -1698,7 +1698,6 @@
 {
     XGL_IMAGE                               originalImage;
 } XGL_PEER_IMAGE_OPEN_INFO;
-
 typedef struct _XGL_SUBRESOURCE_LAYOUT
 {
     XGL_GPU_SIZE                            offset;                 // Specified in bytes
@@ -2087,12 +2086,18 @@
     XGL_FLAGS                               flags;      // XGL_CMD_BUFFER_BUILD_FLAGS
 } XGL_CMD_BUFFER_BEGIN_INFO;
 
+typedef struct _XGL_RENDER_PASS_BEGIN
+{
+    XGL_RENDER_PASS                         renderPass;
+    XGL_FRAMEBUFFER                         framebuffer;
+} XGL_RENDER_PASS_BEGIN;
+
 typedef struct _XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO
 {
     XGL_STRUCTURE_TYPE                      sType;      // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO
     const void*                             pNext;      // Pointer to next structure
 
-    XGL_RENDER_PASS                         renderPass;
+    XGL_RENDER_PASS_BEGIN                   renderPassContinue;  // Only needed when a render pass is split across two command buffers
 } XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO;
 
 // Union allowing specification of floating point or raw color data. Actual value selected is based on image being cleared.
@@ -2114,11 +2119,17 @@
     const void*                             pNext;      // Pointer to next structure
 
     XGL_RECT                                renderArea;
-    XGL_FRAMEBUFFER                         framebuffer;
     uint32_t                                colorAttachmentCount;
-    const XGL_ATTACHMENT_LOAD_OP*           pColorLoadOps;               // Array of size equivalent to the number of attachments in the framebuffer
-    const XGL_ATTACHMENT_STORE_OP*          pColorStoreOps;              // Array of size equivalent to the number of attachments in the framebuffer
-    const XGL_CLEAR_COLOR*                  pColorLoadClearValues;       // Array of size equivalent to the number of attachments in the framebuffer
+    XGL_EXTENT2D                            extent;
+    uint32_t                                sampleCount;
+    uint32_t                                layers;
+    const XGL_FORMAT*                       pColorFormats;
+    const XGL_IMAGE_LAYOUT*                 pColorLayouts;
+    const XGL_ATTACHMENT_LOAD_OP*           pColorLoadOps;
+    const XGL_ATTACHMENT_STORE_OP*          pColorStoreOps;
+    const XGL_CLEAR_COLOR*                  pColorLoadClearValues;
+    XGL_FORMAT                              depthStencilFormat;
+    XGL_IMAGE_LAYOUT                        depthStencilLayout;
     XGL_ATTACHMENT_LOAD_OP                  depthLoadOp;
     float                                   depthLoadClearValue;
     XGL_ATTACHMENT_STORE_OP                 depthStoreOp;
@@ -2336,7 +2347,7 @@
 typedef void       (XGLAPI *xglCmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
 typedef XGL_RESULT (XGLAPI *xglCreateFramebufferType)(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer);
 typedef XGL_RESULT (XGLAPI *xglCreateRenderPassType)(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass);
-typedef void       (XGLAPI *xglCmdBeginRenderPassType)(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass);
+typedef void       (XGLAPI *xglCmdBeginRenderPassType)(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN* pRenderPassBegin);
 typedef void       (XGLAPI *xglCmdEndRenderPassType)(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass);
 
 #ifdef XGL_PROTOTYPES
@@ -2980,7 +2991,7 @@
 
 void XGLAPI xglCmdBeginRenderPass(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_RENDER_PASS                             renderPass);
+    const XGL_RENDER_PASS_BEGIN*                pRenderPassBegin);
 
 void XGLAPI xglCmdEndRenderPass(
     XGL_CMD_BUFFER                              cmdBuffer,
diff --git a/layers/draw_state.c b/layers/draw_state.c
index 979b136..9fa0cc2 100644
--- a/layers/draw_state.c
+++ b/layers/draw_state.c
@@ -2625,7 +2625,7 @@
     nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
+XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN *pRenderPassBegin)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2637,7 +2637,7 @@
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
-    nextTable.CmdBeginRenderPass(cmdBuffer, renderPass);
+    nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
 }
 
 XGL_LAYER_EXPORT void XGLAPI xglCmdEndRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 3687c06..c37930c 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -509,10 +509,10 @@
         uint32_t psoNumSamples = getNumSamples(pipeline);
         if (pCB->activeRenderPass) {
             XGL_RENDER_PASS_CREATE_INFO* pRPCI = renderPassMap[pCB->activeRenderPass];
-            XGL_FRAMEBUFFER_CREATE_INFO* pFBCI = frameBufferMap[pRPCI->framebuffer];
+            XGL_FRAMEBUFFER_CREATE_INFO* pFBCI = frameBufferMap[pCB->framebuffer];
             if (psoNumSamples != pFBCI->sampleCount) {
                 char str[1024];
-                sprintf(str, "Num samples mismatche! Binding PSO (%p) with %u samples while current RenderPass (%p) uses FB (%p) with %u samples!", (void*)pipeline, psoNumSamples, (void*)pCB->activeRenderPass, (void*)pRPCI->framebuffer, pFBCI->sampleCount);
+                sprintf(str, "Num samples mismatche! Binding PSO (%p) with %u samples while current RenderPass (%p) uses FB (%p) with %u samples!", (void*)pipeline, psoNumSamples, (void*)pCB->activeRenderPass, (void*)pCB->framebuffer, pFBCI->sampleCount);
                 layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS", str);
             }
         } else {
@@ -1894,7 +1894,7 @@
             if (pBeginInfo->pNext) {
                 XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pCbGfxBI = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pBeginInfo->pNext;
                 if (XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO == pCbGfxBI->sType) {
-                    pCB->activeRenderPass = pCbGfxBI->renderPass;
+                    pCB->activeRenderPass = pCbGfxBI->renderPassContinue.renderPass;
                 }
             }
         }
@@ -2526,21 +2526,21 @@
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
+XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN *pRenderPassBegin)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
         updateCBTracking(cmdBuffer);
         addCmd(pCB, CMD_BEGINRENDERPASS);
-        pCB->activeRenderPass = renderPass;
+        pCB->activeRenderPass = pRenderPassBegin->renderPass;
+        pCB->framebuffer = pRenderPassBegin->framebuffer;
         validatePipelineState(pCB, XGL_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline);
-    }
-    else {
+    } else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
-    nextTable.CmdBeginRenderPass(cmdBuffer, renderPass);
+    nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
 }
 
 XGL_LAYER_EXPORT void XGLAPI xglCmdEndRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
diff --git a/layers/draw_state.h b/layers/draw_state.h
index cb71b34..0fb771e 100644
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -237,6 +237,7 @@
     DYNAMIC_STATE_NODE*             lastBoundDynamicState[XGL_NUM_STATE_BIND_POINT];
     XGL_DESCRIPTOR_SET              lastBoundDescriptorSet;
     XGL_RENDER_PASS                 activeRenderPass;
+    XGL_FRAMEBUFFER                 framebuffer;
 } GLOBAL_CB_NODE;
 
 //prototypes for extension functions
diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c
index 8cf0621..e4a3b7e 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -1642,12 +1642,12 @@
     return result;
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
+XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, const XGL_RENDER_PASS_BEGIN *pRenderPassBegin)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)cmdBuffer, XGL_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
-    nextTable.CmdBeginRenderPass(cmdBuffer, renderPass);
+    nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
 }
 
 XGL_LAYER_EXPORT void XGLAPI xglCmdEndRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_RENDER_PASS renderPass)
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index d6c940f..5683ea2 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -219,6 +219,8 @@
     void InitDepthStencil();
     void XGLTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate);
 
+    XGL_RESULT BeginCommandBuffer(XglCommandBufferObj &cmdBuffer);
+    XGL_RESULT EndCommandBuffer(XglCommandBufferObj &cmdBuffer);
 
 protected:
     XGL_IMAGE m_texture;
@@ -258,6 +260,35 @@
     }
 };
 
+XGL_RESULT XglRenderTest::BeginCommandBuffer(XglCommandBufferObj &cmdBuffer)
+{
+    XGL_RESULT result;
+
+    result = cmdBuffer.BeginCommandBuffer();
+
+    /*
+     * For render test all drawing happens in a single render pass
+     * on a single command buffer.
+     */
+    if (XGL_SUCCESS == result) {
+        cmdBuffer.BeginRenderPass(renderPass(), framebuffer());
+    }
+
+    return result;
+}
+
+XGL_RESULT XglRenderTest::EndCommandBuffer(XglCommandBufferObj &cmdBuffer)
+{
+    XGL_RESULT result;
+
+    cmdBuffer.EndRenderPass(renderPass());
+
+    result = cmdBuffer.EndCommandBuffer();
+
+    return result;
+}
+
+
 void XglRenderTest::GenericDrawPreparation(XglCommandBufferObj *cmdBuffer, XglPipelineObj *pipelineobj, XglDescriptorSetObj *descriptorSet)
 {
     cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color,
@@ -497,18 +528,20 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 #ifdef DUMP_STATE_DOT
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
+
     // render triangle
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
+
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -796,7 +829,8 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
@@ -805,7 +839,8 @@
     cmdBuffer.Draw(0, 6, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
+
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -878,7 +913,7 @@
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
     cmdBuffer.AddRenderTarget(m_renderTargets[1]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -887,11 +922,12 @@
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
+
     // render triangle
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -986,7 +1022,7 @@
     m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size());
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -1002,7 +1038,7 @@
     cmdBuffer.DrawIndexed(0, 6, 0, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -1084,7 +1120,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -1093,11 +1129,12 @@
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
+
     // render triangle
     cmdBuffer.Draw(0, 6, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -1179,7 +1216,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -1188,11 +1225,11 @@
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
-    // render triangle
+    // render two triangles
     cmdBuffer.Draw(0, 6, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -1284,7 +1321,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -1293,11 +1330,12 @@
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
-    // render triangle
+
+    // render two triangles
     cmdBuffer.Draw(0, 6, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -1379,7 +1417,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -1388,11 +1426,12 @@
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
-    // render triangle
+
+    // render two triangles
     cmdBuffer.Draw(0, 6, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -1454,7 +1493,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -1463,11 +1502,12 @@
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
-    // render triangle
+
+    // render two triangles
     cmdBuffer.Draw(0, 6, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -1532,7 +1572,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -1540,11 +1580,12 @@
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
+
     // render triangle
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -1621,7 +1662,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -1630,11 +1671,12 @@
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
-    // render triangle
+
+    // render two triangles
     cmdBuffer.Draw(0, 6, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -1715,7 +1757,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -1724,11 +1766,12 @@
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
-    // render triangle
+
+    // render two triangles
     cmdBuffer.Draw(0, 6, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -1829,7 +1872,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
@@ -1837,11 +1880,13 @@
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
-    // render triangle
+
+    // render triangles
     cmdBuffer.Draw(0, 36, 0, 1);
 
+
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -1899,7 +1944,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -1907,11 +1952,12 @@
     DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
     pDSDumpDot((char*)"triTest2.dot");
 #endif
+
     // render triangle
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -1972,7 +2018,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -1984,7 +2030,7 @@
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -2056,7 +2102,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -2068,7 +2114,7 @@
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -2129,7 +2175,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -2141,7 +2187,7 @@
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -2223,7 +2269,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -2235,7 +2281,7 @@
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -2307,7 +2353,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -2319,7 +2365,7 @@
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -2410,7 +2456,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -2422,7 +2468,7 @@
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -2508,7 +2554,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -2520,7 +2566,7 @@
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -2638,7 +2684,8 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
+
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
     cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0);
@@ -2650,7 +2697,7 @@
     cmdBuffer.Draw(0, 36, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -2760,7 +2807,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -2772,7 +2819,7 @@
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -2876,7 +2923,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -2888,7 +2935,7 @@
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
@@ -3129,7 +3176,7 @@
     XglCommandBufferObj cmdBuffer(m_device);
     cmdBuffer.AddRenderTarget(m_renderTargets[0]);
 
-    ASSERT_XGL_SUCCESS(cmdBuffer.BeginCommandBuffer(renderPass()));
+    ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer));
 
     GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet);
 
@@ -3141,7 +3188,7 @@
     cmdBuffer.Draw(0, 3, 0, 1);
 
     // finalize recording of the command buffer
-    cmdBuffer.EndCommandBuffer();
+    EndCommandBuffer(cmdBuffer);
     cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs());
 
     for (int i = 0; i < m_renderTargets.size(); i++)
diff --git a/tests/xglrenderframework.cpp b/tests/xglrenderframework.cpp
index 9a46f78..3721816 100644
--- a/tests/xglrenderframework.cpp
+++ b/tests/xglrenderframework.cpp
@@ -76,7 +76,7 @@
     if (m_stateDepthStencil) xglDestroyObject(m_stateDepthStencil);
     if (m_stateRaster) xglDestroyObject(m_stateRaster);
     if (m_cmdBuffer) xglDestroyObject(m_cmdBuffer);
-    if (m_frameBuffer) xglDestroyObject(m_frameBuffer);
+    if (m_framebuffer) xglDestroyObject(m_framebuffer);
     if (m_renderPass) xglDestroyObject(m_renderPass);
 
     if (m_stateViewport) {
@@ -174,6 +174,9 @@
 
 void XglRenderFramework::InitRenderTarget(uint32_t targets)
 {
+    std::vector<XGL_ATTACHMENT_LOAD_OP> load_ops;
+    std::vector<XGL_ATTACHMENT_STORE_OP> store_ops;
+    std::vector<XGL_CLEAR_COLOR> clear_colors;
     uint32_t i;
 
     for (i = 0; i < targets; i++) {
@@ -184,16 +187,11 @@
         m_colorBindings[i].view  = img->targetView();
         m_colorBindings[i].layout = XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
         m_renderTargets.push_back(img);
+        load_ops.push_back(XGL_ATTACHMENT_LOAD_OP_LOAD);
+        store_ops.push_back(XGL_ATTACHMENT_STORE_OP_STORE);
+        clear_colors.push_back(m_clear_color);
     }
       // Create Framebuffer and RenderPass with color attachments and any depth/stencil attachment
-    XGL_ATTACHMENT_LOAD_OP load_op = XGL_ATTACHMENT_LOAD_OP_LOAD;
-    XGL_ATTACHMENT_STORE_OP store_op = XGL_ATTACHMENT_STORE_OP_STORE;
-    XGL_CLEAR_COLOR clear_color;
-    clear_color.color.rawColor[0] = 64;
-    clear_color.color.rawColor[1] = 64;
-    clear_color.color.rawColor[2] = 64;
-    clear_color.color.rawColor[3] = 0;
-    clear_color.useRawValue = XGL_TRUE;
     XGL_DEPTH_STENCIL_BIND_INFO *dsBinding;
     if (m_depthStencilBinding.view)
         dsBinding = &m_depthStencilBinding;
@@ -211,19 +209,26 @@
     fb_info.layers = 1;
 
     XGL_RENDER_PASS_CREATE_INFO rp_info;
+
     memset(&rp_info, 0 , sizeof(rp_info));
-    xglCreateFramebuffer(device(), &fb_info, &(m_frameBuffer));
-    rp_info.framebuffer = m_frameBuffer;
+    xglCreateFramebuffer(device(), &fb_info, &m_framebuffer);
+
     rp_info.sType = XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
     rp_info.renderArea.extent.width = m_width;
     rp_info.renderArea.extent.height = m_height;
     rp_info.colorAttachmentCount = m_renderTargets.size();
-    rp_info.pColorLoadOps = &load_op;
-    rp_info.pColorStoreOps = &store_op;
-    rp_info.pColorLoadClearValues = &clear_color;
+    rp_info.pColorFormats = &m_render_target_fmt;
+    rp_info.pColorLayouts = &m_colorBindings[0].layout;
+    rp_info.pColorLoadOps = &load_ops[0];
+    rp_info.pColorStoreOps = &store_ops[0];
+    rp_info.pColorLoadClearValues = &clear_colors[0];
+    rp_info.depthStencilFormat = m_depth_stencil_fmt;
+    rp_info.depthStencilLayout = m_depthStencilBinding.layout;
     rp_info.depthLoadOp = XGL_ATTACHMENT_LOAD_OP_LOAD;
+    rp_info.depthLoadClearValue = m_depth_clear_color;
     rp_info.depthStoreOp = XGL_ATTACHMENT_STORE_OP_STORE;
     rp_info.stencilLoadOp = XGL_ATTACHMENT_LOAD_OP_LOAD;
+    rp_info.stencilLoadClearValue = m_stencil_clear_color;
     rp_info.stencilStoreOp = XGL_ATTACHMENT_STORE_OP_STORE;
     xglCreateRenderPass(device(), &rp_info, &m_renderPass);
 }
@@ -1128,9 +1133,9 @@
     return XGL_SUCCESS;
 }
 
-XGL_RESULT XglCommandBufferObj::BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj)
+XGL_RESULT XglCommandBufferObj::BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj)
 {
-    begin(renderpass_obj);
+    begin(renderpass_obj, framebuffer_obj);
     return XGL_SUCCESS;
 }
 
@@ -1283,6 +1288,21 @@
     }
 }
 
+void XglCommandBufferObj::BeginRenderPass(XGL_RENDER_PASS renderpass, XGL_FRAMEBUFFER framebuffer)
+{
+    XGL_RENDER_PASS_BEGIN rp_begin = {
+        renderpass,
+        framebuffer,
+    };
+
+    xglCmdBeginRenderPass( obj(), &rp_begin);
+}
+
+void XglCommandBufferObj::EndRenderPass(XGL_RENDER_PASS renderpass)
+{
+    xglCmdEndRenderPass( obj(), renderpass);
+}
+
 void XglCommandBufferObj::BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject)
 {
     xglCmdBindDynamicStateObject( obj(), stateBindPoint, stateObject);
diff --git a/tests/xglrenderframework.h b/tests/xglrenderframework.h
index 4bf55f1..531063d 100644
--- a/tests/xglrenderframework.h
+++ b/tests/xglrenderframework.h
@@ -55,6 +55,7 @@
     XGL_DEVICE device() {return m_device->device();}
     XGL_PHYSICAL_GPU gpu() {return objs[0];}
     XGL_RENDER_PASS renderPass() {return m_renderPass;}
+    XGL_FRAMEBUFFER framebuffer() {return m_framebuffer;}
     void InitViewport(float width, float height);
     void InitViewport();
     void InitRenderTarget();
@@ -72,7 +73,7 @@
     XglDevice                              *m_device;
     XGL_CMD_BUFFER                          m_cmdBuffer;
     XGL_RENDER_PASS                         m_renderPass;
-    XGL_FRAMEBUFFER                         m_frameBuffer;
+    XGL_FRAMEBUFFER                         m_framebuffer;
     XGL_MEMORY_REF                          m_memRefs[5];
     XGL_DYNAMIC_RS_STATE_OBJECT             m_stateRaster;
     XGL_DYNAMIC_CB_STATE_OBJECT             m_colorBlend;
@@ -118,7 +119,7 @@
     XglCommandBufferObj(XglDevice *device);
     XGL_CMD_BUFFER GetBufferHandle();
     XGL_RESULT BeginCommandBuffer(XGL_CMD_BUFFER_BEGIN_INFO *pInfo);
-    XGL_RESULT BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj);
+    XGL_RESULT BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj);
     XGL_RESULT BeginCommandBuffer();
     XGL_RESULT EndCommandBuffer();
     void PipelineBarrier(XGL_PIPELINE_BARRIER *barrierPtr);
@@ -131,6 +132,8 @@
     void BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding);
     void BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset);
     void BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject);
+    void BeginRenderPass(XGL_RENDER_PASS renderpass, XGL_FRAMEBUFFER framebuffer);
+    void EndRenderPass(XGL_RENDER_PASS renderpass);
     void Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
     void DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
     void QueueCommandBuffer(XGL_MEMORY_REF *memRefs, uint32_t numMemRefs);
diff --git a/tests/xgltestbinding.cpp b/tests/xgltestbinding.cpp
index fcd91b7..8394566 100644
--- a/tests/xgltestbinding.cpp
+++ b/tests/xgltestbinding.cpp
@@ -914,13 +914,14 @@
     EXPECT(xglBeginCommandBuffer(obj(), info) == XGL_SUCCESS);
 }
 
-void CmdBuffer::begin(XGL_RENDER_PASS renderpass_obj)
+void CmdBuffer::begin(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj)
 {
     XGL_CMD_BUFFER_BEGIN_INFO info = {};
     XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO graphics_cmd_buf_info = {};
     graphics_cmd_buf_info.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO;
     graphics_cmd_buf_info.pNext = NULL;
-    graphics_cmd_buf_info.renderPass = renderpass_obj;
+    graphics_cmd_buf_info.renderPassContinue.renderPass = renderpass_obj;
+    graphics_cmd_buf_info.renderPassContinue.framebuffer = framebuffer_obj;
 
     info.flags = XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT |
           XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
diff --git a/tests/xgltestbinding.h b/tests/xgltestbinding.h
index 4d1f213..86f27f0 100644
--- a/tests/xgltestbinding.h
+++ b/tests/xgltestbinding.h
@@ -591,7 +591,7 @@
 
     // xglBeginCommandBuffer()
     void begin(const XGL_CMD_BUFFER_BEGIN_INFO *info);
-    void begin(XGL_RENDER_PASS renderpass_obj);
+    void begin(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj);
     void begin();
 
     // xglEndCommandBuffer()
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl_xglreplay.cpp b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl_xglreplay.cpp
index f6a55b5..f4caba2 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl_xglreplay.cpp
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl_xglreplay.cpp
@@ -832,18 +832,8 @@
 {
     XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
     glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
-    XGL_RENDER_PASS_CREATE_INFO *pInfo = (XGL_RENDER_PASS_CREATE_INFO *) pPacket->pCreateInfo;
-    // remap framebuffer
-    XGL_FRAMEBUFFER savedFB = 0, *pFB = &(pInfo->framebuffer);
-    if (*pFB != NULL)
-    {
-        savedFB = pInfo->framebuffer;
-        *pFB = m_objMapper.remap(pInfo->framebuffer);
-    }
     XGL_RENDER_PASS local_renderpass;
     replayResult = m_xglFuncs.real_xglCreateRenderPass(m_objMapper.remap(pPacket->device), pPacket->pCreateInfo, &local_renderpass);
-    if (*pFB != NULL)
-        pInfo->framebuffer = savedFB;
     if (replayResult == XGL_SUCCESS)
     {
         m_objMapper.add_to_map(pPacket->pRenderPass, &local_renderpass);
@@ -858,7 +848,7 @@
     glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
     XGL_CMD_BUFFER_BEGIN_INFO* pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*)pPacket->pBeginInfo;
     // assume only zero or one graphics_begin_info in the chain
-    XGL_RENDER_PASS savedRP, *pRP;
+    XGL_RENDER_PASS_BEGIN savedRP, *pRP;
     XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *pGInfo = NULL;
     while (pInfo != NULL)
     {
@@ -866,16 +856,17 @@
         if (pInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO)
         {
             pGInfo = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *) pInfo;
-            savedRP = pGInfo->renderPass;
-            pRP = &(pGInfo->renderPass);
-            *pRP = m_objMapper.remap(pGInfo->renderPass);
+            savedRP = pGInfo->renderPassContinue;
+            pRP = &(pGInfo->renderPassContinue);
+            pRP->renderPass = m_objMapper.remap(savedRP.renderPass);
+            pRP->framebuffer = m_objMapper.remap(savedRP.framebuffer);
             break;
         }
         pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*) pInfo->pNext;
     }
     replayResult = m_xglFuncs.real_xglBeginCommandBuffer(m_objMapper.remap(pPacket->cmdBuffer), pPacket->pBeginInfo);
     if (pGInfo != NULL)
-        pGInfo->renderPass = savedRP;
+        pGInfo->renderPassContinue = savedRP;
     CHECK_RETURN_VALUE(xglBeginCommandBuffer);
     return returnValue;
 }
diff --git a/xgl.py b/xgl.py
index e917f82..6afe794 100644
--- a/xgl.py
+++ b/xgl.py
@@ -808,7 +808,7 @@
 
         Proto("void", "CmdBeginRenderPass",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_RENDER_PASS", "renderPass")]),
+             Param("const XGL_RENDER_PASS_BEGIN*", "pRenderPassBegin")]),
 
         Proto("void", "CmdEndRenderPass",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),