xgl: Proposal to remove XGL_FRAMEBUFFER

bug # 13323
alpha header: r29635

Don't actually remove XGL_FRAMEBUFFER but do change how
RenderPass and Framebuffer are connected. Some comments
from the bug:

- Created a new structure XGL_RENDER_PASS_BEGIN that contains
both the XGL_RENDER_PASS and XGL_FRAMEBUFFER.

- XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO and xglCmdBeginRenderPass
both use XGL_RENDER_PASS_BEGIN to ensure they stay consistent.

- Renamed the member in XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO to
renderPassContinue with a comment to clarify that this is
only needed when a render pass is split across two command buffer.

The last has the biggest impact on this patch. The tests now
directly call CmdBeginRenderPass and CmdEndRenderPass in the
command buffer rather than set the BEGIN_INFO to a render pass and
have the driver implicitly do BeginRenderPass and EndRenderPass.
It would probably still work, but didn't seem to match the intent
with this change in the header file.

9 files changed, 67 insertions, 47 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 6f2d24c7..426b712b 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -207,6 +207,7 @@ struct demo {
     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 @@ static void demo_draw_build_cmd(struct demo *demo, XGL_CMD_BUFFER cmd_buf)
     };
     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 @@ static void demo_draw_build_cmd(struct demo *demo, XGL_CMD_BUFFER cmd_buf)
          .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 @@ static void demo_draw_build_cmd(struct demo *demo, XGL_CMD_BUFFER cmd_buf)
     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 @@ static void demo_draw_build_cmd(struct demo *demo, XGL_CMD_BUFFER cmd_buf)
             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 d3a03779..43824b68 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -110,13 +110,9 @@ static void demo_draw_build_cmd(struct demo *demo)
     };
     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 @@ static void demo_draw_build_cmd(struct demo *demo)
          .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 @@ static void demo_draw_build_cmd(struct demo *demo)
 
     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 @@ static void demo_draw_build_cmd(struct demo *demo)
             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/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index f6fa9e0d..2db8f646 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -1995,7 +1995,7 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(
 
 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 bffc7dfa..1955f8ae 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 @@ typedef struct _XGL_PEER_IMAGE_OPEN_INFO
 {
     XGL_IMAGE                               originalImage;
 } XGL_PEER_IMAGE_OPEN_INFO;
-
 typedef struct _XGL_SUBRESOURCE_LAYOUT
 {
     XGL_GPU_SIZE                            offset;                 // Specified in bytes
@@ -2087,12 +2086,18 @@ typedef struct _XGL_CMD_BUFFER_BEGIN_INFO
     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 @@ typedef struct _XGL_RENDER_PASS_CREATE_INFO
     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 *xglCmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuff
 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 @@ XGL_RESULT XGLAPI xglCreateRenderPass(
 
 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 979b1361..9fa0cc2a 100644
--- a/layers/draw_state.c
+++ b/layers/draw_state.c
@@ -2625,7 +2625,7 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdSaveAtomicCounters(XGL_CMD_BUFFER cmdBuffer,
     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 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdBeginRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL
         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 3687c06c..c37930cf 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -509,10 +509,10 @@ static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const XGL_PIPELINE_
         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 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(XGL_CMD_BUFFER cmdBuffe
             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 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(XGL_DEVICE device, const
     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 cb71b34f..0fb771e5 100644
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -237,6 +237,7 @@ typedef struct _GLOBAL_CB_NODE {
     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 8cf06211..e4a3b7e8 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -1642,12 +1642,12 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(XGL_DEVICE device, const
     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/xgl.py b/xgl.py
index e917f828..6afe7946 100644
--- a/xgl.py
+++ b/xgl.py
@@ -808,7 +808,7 @@ core = Extension(
 
         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"),