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,
(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,
ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(
XGL_DEVICE device,
- size_t dataSize,
+ size_t dataSize,
const void* pData,
XGL_PIPELINE* pPipeline)
{
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;
#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"
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)
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;
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);
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);
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,
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
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,
xglCreateDepthStencilViewType CreateDepthStencilView;
xglCreateShaderType CreateShader;
xglCreateGraphicsPipelineType CreateGraphicsPipeline;
+ xglCreateGraphicsPipelineDerivativeType CreateGraphicsPipelineDerivative;
xglCreateComputePipelineType CreateComputePipeline;
xglStorePipelineType StorePipeline;
xglLoadPipelineType LoadPipeline;
- xglCreatePipelineDeltaType CreatePipelineDelta;
+ xglLoadPipelineDerivativeType LoadPipelineDerivative;
xglCreateSamplerType CreateSampler;
xglCreateDescriptorSetLayoutType CreateDescriptorSetLayout;
xglBeginDescriptorRegionUpdateType BeginDescriptorRegionUpdate;
xglEndCommandBufferType EndCommandBuffer;
xglResetCommandBufferType ResetCommandBuffer;
xglCmdBindPipelineType CmdBindPipeline;
- xglCmdBindPipelineDeltaType CmdBindPipelineDelta;
xglCmdBindDynamicStateObjectType CmdBindDynamicStateObject;
xglCmdBindDescriptorSetType CmdBindDescriptorSet;
xglCmdBindVertexBufferType CmdBindVertexBuffer;
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) {
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;
}
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);
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"))
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"))
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);
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"))
"XGL_DEPTH_STENCIL_VIEW",
"XGL_SHADER",
"XGL_PIPELINE",
- "XGL_PIPELINE_DELTA",
"XGL_SAMPLER",
"XGL_DESCRIPTOR_SET",
"XGL_DESCRIPTOR_SET_LAYOUT",
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"),
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"),
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"),
"XGL_DEPTH_STENCIL_VIEW",
"XGL_SHADER",
"XGL_PIPELINE",
- "XGL_PIPELINE_DELTA",
"XGL_SAMPLER",
"XGL_DESCRIPTOR_SET",
"XGL_DESCRIPTOR_SET_LAYOUT",