xgl: Remove PIPELINE_DELTA.

bug: 13065
header: 0.60.0

Remove PIPELINE_DELTA.

Add functions for creating and loading pipeline derivatives.

v2: fix warnings (olv)

6 files changed, 96 insertions, 63 deletions

diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 33cff858..3efeba15 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -1075,14 +1075,6 @@ ICD_EXPORT void XGLAPI xglCmdBindPipeline(
     NULLDRV_LOG_FUNC;
 }
 
-ICD_EXPORT void XGLAPI xglCmdBindPipelineDelta(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
-    XGL_PIPELINE_DELTA                          delta)
-{
-    NULLDRV_LOG_FUNC;
-}
-
 ICD_EXPORT void XGLAPI xglCmdBindDynamicStateObject(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_STATE_BIND_POINT                        stateBindPoint,
@@ -1652,6 +1644,19 @@ ICD_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
             (struct nulldrv_pipeline **) pPipeline);
 }
 
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
+    XGL_DEVICE                                  device,
+    const XGL_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
+    XGL_PIPELINE                                basePipeline,
+    XGL_PIPELINE*                               pPipeline)
+{
+    NULLDRV_LOG_FUNC;
+    struct nulldrv_dev *dev = nulldrv_dev(device);
+
+    return graphics_pipeline_create(dev, pCreateInfo,
+            (struct nulldrv_pipeline **) pPipeline);
+}
+
 ICD_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(
     XGL_DEVICE                                  device,
     const XGL_COMPUTE_PIPELINE_CREATE_INFO*     pCreateInfo,
@@ -1672,7 +1677,7 @@ ICD_EXPORT XGL_RESULT XGLAPI xglStorePipeline(
 
 ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(
     XGL_DEVICE                                  device,
-    size_t                                    dataSize,
+    size_t                                    	dataSize,
     const void*                                 pData,
     XGL_PIPELINE*                               pPipeline)
 {
@@ -1680,11 +1685,12 @@ ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(
     return XGL_SUCCESS;
 }
 
-ICD_EXPORT XGL_RESULT XGLAPI xglCreatePipelineDelta(
+ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipelineDerivative(
     XGL_DEVICE                                  device,
-    XGL_PIPELINE                                p1,
-    XGL_PIPELINE                                p2,
-    XGL_PIPELINE_DELTA*                         delta)
+    size_t                                    	dataSize,
+    const void*                                 pData,
+    XGL_PIPELINE				basePipeline,
+    XGL_PIPELINE*                               pPipeline)
 {
     NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
diff --git a/include/xgl.h b/include/xgl.h
index dd12fc3f..b1c7c883 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, 59, 0)
+#define XGL_API_VERSION XGL_MAKE_VERSION(0, 60, 0)
 
 #ifdef __cplusplus
 extern "C"
@@ -69,7 +69,6 @@ XGL_DEFINE_SUBCLASS_HANDLE(XGL_COLOR_ATTACHMENT_VIEW, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEPTH_STENCIL_VIEW, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_SHADER, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE_DELTA, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_SAMPLER, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET_LAYOUT, XGL_OBJECT)
@@ -1220,6 +1219,7 @@ typedef enum _XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS
 typedef enum _XGL_PIPELINE_CREATE_FLAGS
 {
     XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT            = 0x00000001,
+    XGL_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT               = 0x00000002,
     XGL_MAX_ENUM(_XGL_PIPELINE_CREATE_FLAGS)
 } XGL_PIPELINE_CREATE_FLAGS;
 
@@ -2299,10 +2299,11 @@ typedef XGL_RESULT (XGLAPI *xglCreateColorAttachmentViewType)(XGL_DEVICE device,
 typedef XGL_RESULT (XGLAPI *xglCreateDepthStencilViewType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView);
 typedef XGL_RESULT (XGLAPI *xglCreateShaderType)(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader);
 typedef XGL_RESULT (XGLAPI *xglCreateGraphicsPipelineType)(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
+typedef XGL_RESULT (XGLAPI *xglCreateGraphicsPipelineDerivativeType)(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline);
 typedef XGL_RESULT (XGLAPI *xglCreateComputePipelineType)(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
 typedef XGL_RESULT (XGLAPI *xglStorePipelineType)(XGL_PIPELINE pipeline, size_t* pDataSize, void* pData);
 typedef XGL_RESULT (XGLAPI *xglLoadPipelineType)(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE* pPipeline);
-typedef XGL_RESULT (XGLAPI *xglCreatePipelineDeltaType)(XGL_DEVICE device, XGL_PIPELINE p1, XGL_PIPELINE p2, XGL_PIPELINE_DELTA* delta);
+typedef XGL_RESULT (XGLAPI *xglLoadPipelineDerivativeType)(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline);
 typedef XGL_RESULT (XGLAPI *xglCreateSamplerType)(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler);
 typedef XGL_RESULT (XGLAPI *xglCreateDescriptorSetLayoutType)(XGL_DEVICE device, XGL_FLAGS stageFlags, const uint32_t* pSetBindPoints, XGL_DESCRIPTOR_SET_LAYOUT priorSetLayout, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pSetLayoutInfoList, XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout);
 typedef XGL_RESULT (XGLAPI *xglBeginDescriptorRegionUpdateType)(XGL_DEVICE device, XGL_DESCRIPTOR_UPDATE_MODE updateMode);
@@ -2321,7 +2322,6 @@ typedef XGL_RESULT (XGLAPI *xglBeginCommandBufferType)(XGL_CMD_BUFFER cmdBuffer,
 typedef XGL_RESULT (XGLAPI *xglEndCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
 typedef XGL_RESULT (XGLAPI *xglResetCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
 typedef void       (XGLAPI *xglCmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline);
-typedef void       (XGLAPI *xglCmdBindPipelineDeltaType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta);
 typedef void       (XGLAPI *xglCmdBindDynamicStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state);
 typedef void       (XGLAPI *xglCmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET descriptorSet, const uint32_t* pUserData);
 typedef void       (XGLAPI *xglCmdBindIndexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
@@ -2666,6 +2666,12 @@ XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
     const XGL_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
     XGL_PIPELINE*                               pPipeline);
 
+XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
+    XGL_DEVICE                                  device,
+    const XGL_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
+    XGL_PIPELINE                                basePipeline,
+    XGL_PIPELINE*                               pPipeline);
+
 XGL_RESULT XGLAPI xglCreateComputePipeline(
     XGL_DEVICE                                  device,
     const XGL_COMPUTE_PIPELINE_CREATE_INFO*     pCreateInfo,
@@ -2682,11 +2688,12 @@ XGL_RESULT XGLAPI xglLoadPipeline(
     const void*                                 pData,
     XGL_PIPELINE*                               pPipeline);
 
-XGL_RESULT XGLAPI xglCreatePipelineDelta(
+XGL_RESULT XGLAPI xglLoadPipelineDerivative(
     XGL_DEVICE                                  device,
-    XGL_PIPELINE                                p1,
-    XGL_PIPELINE                                p2,
-    XGL_PIPELINE_DELTA*                         delta);
+    size_t                                      dataSize,
+    const void*                                 pData,
+    XGL_PIPELINE                                basePipeline,
+    XGL_PIPELINE*                               pPipeline);
 
 // Sampler functions
 
@@ -2786,11 +2793,6 @@ void XGLAPI xglCmdBindPipeline(
     XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
     XGL_PIPELINE                                pipeline);
 
-void XGLAPI xglCmdBindPipelineDelta(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
-    XGL_PIPELINE_DELTA                          delta);
-
 void XGLAPI xglCmdBindDynamicStateObject(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_STATE_BIND_POINT                        stateBindPoint,
diff --git a/include/xglLayer.h b/include/xglLayer.h
index 81da19ec..cc9f0e98 100644
--- a/include/xglLayer.h
+++ b/include/xglLayer.h
@@ -81,10 +81,11 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE
     xglCreateDepthStencilViewType CreateDepthStencilView;
     xglCreateShaderType CreateShader;
     xglCreateGraphicsPipelineType CreateGraphicsPipeline;
+    xglCreateGraphicsPipelineDerivativeType CreateGraphicsPipelineDerivative;
     xglCreateComputePipelineType CreateComputePipeline;
     xglStorePipelineType StorePipeline;
     xglLoadPipelineType LoadPipeline;
-    xglCreatePipelineDeltaType CreatePipelineDelta;
+    xglLoadPipelineDerivativeType LoadPipelineDerivative;
     xglCreateSamplerType CreateSampler;
     xglCreateDescriptorSetLayoutType CreateDescriptorSetLayout;
     xglBeginDescriptorRegionUpdateType BeginDescriptorRegionUpdate;
@@ -103,7 +104,6 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE
     xglEndCommandBufferType EndCommandBuffer;
     xglResetCommandBufferType ResetCommandBuffer;
     xglCmdBindPipelineType CmdBindPipeline;
-    xglCmdBindPipelineDeltaType CmdBindPipelineDelta;
     xglCmdBindDynamicStateObjectType CmdBindDynamicStateObject;
     xglCmdBindDescriptorSetType CmdBindDescriptorSet;
     xglCmdBindVertexBufferType CmdBindVertexBuffer;
diff --git a/layers/draw_state.c b/layers/draw_state.c
index c764412b..5148be82 100644
--- a/layers/draw_state.c
+++ b/layers/draw_state.c
@@ -1666,13 +1666,8 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImageView(XGL_DEVICE device, const X
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+static void track_pipeline(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
 {
-    XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
-    // Create LL HEAD for this Pipeline
-    char str[1024];
-    sprintf(str, "Created Gfx Pipeline %p", (void*)*pPipeline);
-    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pPipeline, 0, DRAWSTATE_NONE, "DS", str);
     loader_platform_thread_lock_mutex(&globalLock);
     PIPELINE_NODE *pTrav = g_pPipelineHead;
     if (pTrav) {
@@ -1695,6 +1690,35 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device,
     pTrav->pipeline = *pPipeline;
     initPipeline(pTrav, pCreateInfo);
     loader_platform_thread_unlock_mutex(&globalLock);
+}
+
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+{
+    XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+    // Create LL HEAD for this Pipeline
+    char str[1024];
+    sprintf(str, "Created Gfx Pipeline %p", (void*)*pPipeline);
+    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pPipeline, 0, DRAWSTATE_NONE, "DS", str);
+
+    track_pipeline(pCreateInfo, pPipeline);
+
+    return result;
+}
+
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
+        XGL_DEVICE device,
+        const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+        XGL_PIPELINE basePipeline,
+        XGL_PIPELINE* pPipeline)
+{
+    XGL_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+    // Create LL HEAD for this Pipeline
+    char str[1024];
+    sprintf(str, "Created Gfx Pipeline %p (derived from pipeline %p)", (void*)*pPipeline, basePipeline);
+    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pPipeline, 0, DRAWSTATE_NONE, "DS", str);
+
+    track_pipeline(pCreateInfo, pPipeline);
+
     return result;
 }
 
@@ -2107,22 +2131,6 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdBindPipeline(XGL_CMD_BUFFER cmdBuffer, XGL_PI
     nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindPipelineDelta(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta)
-{
-    GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
-    if (pCB) {
-        // TODO : Handle storing Pipeline Deltas to cmd buffer here
-        updateCBTracking(cmdBuffer);
-        addCmd(pCB, CMD_BINDPIPELINEDELTA);
-    }
-    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.CmdBindPipelineDelta(cmdBuffer, pipelineBindPoint, delta);
-}
-
 XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state)
 {
     setLastBoundDynamicState(cmdBuffer, state, stateBindPoint);
@@ -2837,6 +2845,8 @@ XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* f
         return (void*) xglCreateImageView;
     if (!strcmp(funcName, "xglCreateGraphicsPipeline"))
         return (void*) xglCreateGraphicsPipeline;
+    if (!strcmp(funcName, "xglCreateGraphicsPipelineDerivative"))
+        return (void*) xglCreateGraphicsPipelineDerivative;
     if (!strcmp(funcName, "xglCreateSampler"))
         return (void*) xglCreateSampler;
     if (!strcmp(funcName, "xglCreateDescriptorSetLayout"))
@@ -2873,8 +2883,6 @@ XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* f
         return (void*) xglResetCommandBuffer;
     if (!strcmp(funcName, "xglCmdBindPipeline"))
         return (void*) xglCmdBindPipeline;
-    if (!strcmp(funcName, "xglCmdBindPipelineDelta"))
-        return (void*) xglCmdBindPipelineDelta;
     if (!strcmp(funcName, "xglCmdBindDynamicStateObject"))
         return (void*) xglCmdBindDynamicStateObject;
     if (!strcmp(funcName, "xglCmdBindDescriptorSet"))
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 72fae402..2d840dc4 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1217,6 +1217,21 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device,
     return result;
 }
 
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
+        XGL_DEVICE device,
+        const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+        XGL_PIPELINE basePipeline,
+        XGL_PIPELINE* pPipeline)
+{
+    XGL_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+    if (result == XGL_SUCCESS) {
+        loader_platform_thread_lock_mutex(&globalLock);
+        insertGlobalObjectNode(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline");
+        loader_platform_thread_unlock_mutex(&globalLock);
+    }
+    return result;
+}
+
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
 {
     XGL_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
@@ -1828,6 +1843,8 @@ XGL_LAYER_EXPORT void* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const char* f
         return (void*) xglCreateShader;
     if (!strcmp(funcName, "xglCreateGraphicsPipeline"))
         return (void*) xglCreateGraphicsPipeline;
+    if (!strcmp(funcName, "xglCreateGraphicsPipelineDerivative"))
+        return (void*) xglCreateGraphicsPipelineDerivative;
     if (!strcmp(funcName, "xglCreateComputePipeline"))
         return (void*) xglCreateComputePipeline;
     if (!strcmp(funcName, "xglCreateSampler"))
diff --git a/xgl.py b/xgl.py
index 1da38e6a..04d80f78 100644
--- a/xgl.py
+++ b/xgl.py
@@ -198,7 +198,6 @@ core = Extension(
         "XGL_DEPTH_STENCIL_VIEW",
         "XGL_SHADER",
         "XGL_PIPELINE",
-        "XGL_PIPELINE_DELTA",
         "XGL_SAMPLER",
         "XGL_DESCRIPTOR_SET",
         "XGL_DESCRIPTOR_SET_LAYOUT",
@@ -484,6 +483,12 @@ core = Extension(
              Param("const XGL_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"),
              Param("XGL_PIPELINE*", "pPipeline")]),
 
+        Proto("XGL_RESULT", "CreateGraphicsPipelineDerivative",
+            [Param("XGL_DEVICE", "device"),
+             Param("const XGL_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"),
+             Param("XGL_PIPELINE", "basePipeline"),
+             Param("XGL_PIPELINE*", "pPipeline")]),
+
         Proto("XGL_RESULT", "CreateComputePipeline",
             [Param("XGL_DEVICE", "device"),
              Param("const XGL_COMPUTE_PIPELINE_CREATE_INFO*", "pCreateInfo"),
@@ -500,11 +505,12 @@ core = Extension(
              Param("const void*", "pData"),
              Param("XGL_PIPELINE*", "pPipeline")]),
 
-        Proto("XGL_RESULT", "CreatePipelineDelta",
+        Proto("XGL_RESULT", "LoadPipelineDerivative",
             [Param("XGL_DEVICE", "device"),
-             Param("XGL_PIPELINE", "p1"),
-             Param("XGL_PIPELINE", "p2"),
-             Param("XGL_PIPELINE_DELTA*", "delta")]),
+             Param("size_t", "dataSize"),
+             Param("const void*", "pData"),
+             Param("XGL_PIPELINE", "basePipeline"),
+             Param("XGL_PIPELINE*", "pPipeline")]),
 
         Proto("XGL_RESULT", "CreateSampler",
             [Param("XGL_DEVICE", "device"),
@@ -594,11 +600,6 @@ core = Extension(
              Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
              Param("XGL_PIPELINE", "pipeline")]),
 
-        Proto("void", "CmdBindPipelineDelta",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
-             Param("XGL_PIPELINE_DELTA", "delta")]),
-
         Proto("void", "CmdBindDynamicStateObject",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_STATE_BIND_POINT", "stateBindPoint"),
@@ -928,7 +929,6 @@ object_list = [
     "XGL_DEPTH_STENCIL_VIEW",
     "XGL_SHADER",
     "XGL_PIPELINE",
-    "XGL_PIPELINE_DELTA",
     "XGL_SAMPLER",
     "XGL_DESCRIPTOR_SET",
     "XGL_DESCRIPTOR_SET_LAYOUT",