driver:implement changes for Dynamic State
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index 221c60c..aefe657 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -201,13 +201,15 @@
// const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
// XGL_GPU_MEMORY* pMem);
XGL_MEMORY_ALLOC_INFO mem_info;
+ XGL_UINT heapInfo[mem_req.heapCount];
memset(&mem_info, 0, sizeof(mem_info));
mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.allocationSize = mem_req.size;
mem_info.alignment = mem_req.alignment;
mem_info.heapCount = mem_req.heapCount;
- memcpy(mem_info.heaps, mem_req.heaps, sizeof(XGL_UINT)*XGL_MAX_MEMORY_HEAPS);
+ mem_info.pHeaps = heapInfo;
+ memcpy(heapInfo, mem_req.pHeaps, sizeof(XGL_UINT)*mem_info.heapCount);
mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
mem_info.flags = XGL_MEMORY_ALLOC_SHAREABLE_BIT;
err = xglAllocMemory(device(), &mem_info, &m_image_mem);
diff --git a/tests/init.cpp b/tests/init.cpp
index 75ccd5e..a97283e 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -159,12 +159,14 @@
XGL_MEMORY_ALLOC_INFO alloc_info = {};
XGL_GPU_MEMORY gpu_mem;
XGL_UINT8 *pData;
+ XGL_UINT localHeap[1] = {0};
alloc_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
alloc_info.allocationSize = 1024 * 1024; // 1MB
alloc_info.alignment = 0;
alloc_info.heapCount = 1;
- alloc_info.heaps[0] = 0; // TODO: Reference other heaps
+ alloc_info.pHeaps = localHeap;
+
// TODO: Pick heap properties indicated by heap info
alloc_info.flags = XGL_MEMORY_HEAP_CPU_VISIBLE_BIT;
@@ -220,12 +222,14 @@
ASSERT_NE(0, mem_req.size) << "xglGetObjectInfo (Event): Failed - expect events to require memory";
+ XGL_UINT heapInfo[mem_req.heapCount];
memset(&mem_info, 0, sizeof(mem_info));
mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.allocationSize = mem_req.size;
mem_info.alignment = mem_req.alignment;
mem_info.heapCount = mem_req.heapCount;
- memcpy(mem_info.heaps, mem_req.heaps, sizeof(XGL_UINT)*XGL_MAX_MEMORY_HEAPS);
+ mem_info.pHeaps = heapInfo;
+ memcpy(heapInfo, mem_req.pHeaps, sizeof(XGL_UINT)*mem_info.heapCount);
mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
mem_info.flags = XGL_MEMORY_ALLOC_SHAREABLE_BIT;
err = xglAllocMemory(device(), &mem_info, &event_mem);
@@ -352,13 +356,16 @@
XGL_MEMORY_ALLOC_INFO mem_info;
XGL_GPU_MEMORY query_mem;
+ XGL_UINT heapInfo[mem_req.heapCount];
+
memset(&mem_info, 0, sizeof(mem_info));
mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
// TODO: Is a simple multiple all that's needed here?
mem_info.allocationSize = mem_req.size * MAX_QUERY_SLOTS;
mem_info.alignment = mem_req.alignment;
mem_info.heapCount = mem_req.heapCount;
- memcpy(mem_info.heaps, mem_req.heaps, sizeof(XGL_UINT)*XGL_MAX_MEMORY_HEAPS);
+ mem_info.pHeaps = heapInfo;
+ memcpy(heapInfo, mem_req.pHeaps, sizeof(XGL_UINT)*mem_info.heapCount);
mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
// TODO: are the flags right?
@@ -625,12 +632,14 @@
XGL_MEMORY_ALLOC_INFO mem_info;
XGL_GPU_MEMORY image_mem;
+ XGL_UINT heapInfo[mem_req.heapCount];
memset(&mem_info, 0, sizeof(mem_info));
mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.allocationSize = mem_req.size;
mem_info.alignment = mem_req.alignment;
mem_info.heapCount = mem_req.heapCount;
- memcpy(mem_info.heaps, mem_req.heaps, sizeof(XGL_UINT)*XGL_MAX_MEMORY_HEAPS);
+ mem_info.pHeaps = heapInfo;
+ memcpy(heapInfo, mem_req.pHeaps, sizeof(XGL_UINT)*mem_info.heapCount);
mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
mem_info.flags = XGL_MEMORY_ALLOC_SHAREABLE_BIT;
err = xglAllocMemory(device(), &mem_info, &image_mem);
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index 3773263..fb54b69 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -266,7 +266,6 @@
cmdBuffer->BindStateObject(XGL_STATE_BIND_VIEWPORT, m_stateViewport);
cmdBuffer->BindStateObject(XGL_STATE_BIND_COLOR_BLEND, m_colorBlend);
cmdBuffer->BindStateObject(XGL_STATE_BIND_DEPTH_STENCIL, m_stateDepthStencil);
- cmdBuffer->BindStateObject(XGL_STATE_BIND_MSAA, m_stateMsaa);
pipelineobj->CreateXGLPipeline(descriptorSet);
cmdBuffer->BindPipeline(pipelineobj->GetPipelineHandle());
descriptorSet->CreateXGLDescriptorSet();
@@ -372,11 +371,13 @@
ASSERT_XGL_SUCCESS(err);
ASSERT_EQ(mem_reqs_size, sizeof(mem_reqs));
+ XGL_UINT heapInfo[mem_reqs.heapCount];
mem_alloc.allocationSize = mem_reqs.size;
mem_alloc.alignment = mem_reqs.alignment;
mem_alloc.heapCount = mem_reqs.heapCount;
- memcpy(mem_alloc.heaps, mem_reqs.heaps,
- sizeof(mem_reqs.heaps[0]) * mem_reqs.heapCount);
+ mem_alloc.pHeaps = heapInfo;
+ memcpy(heapInfo, mem_reqs.pHeaps,
+ sizeof(mem_reqs.pHeaps) * mem_reqs.heapCount);
/* allocate memory */
err = xglAllocMemory(device(), &mem_alloc, &m_depthStencilMem);
@@ -386,22 +387,17 @@
err = xglBindObjectMemory(m_depthStencilImage, m_depthStencilMem, 0);
ASSERT_XGL_SUCCESS(err);
- XGL_DEPTH_STENCIL_STATE_CREATE_INFO depthStencil = {};
- depthStencil.sType = XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO;
- depthStencil.depthTestEnable = XGL_TRUE;
- depthStencil.depthWriteEnable = XGL_TRUE;
- depthStencil.depthFunc = XGL_COMPARE_LESS_EQUAL;
- depthStencil.depthBoundsEnable = XGL_FALSE;
+ XGL_DYNAMIC_DS_STATE_CREATE_INFO depthStencil = {};
+ depthStencil.sType = XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
+
depthStencil.minDepth = 0.f;
depthStencil.maxDepth = 1.f;
- depthStencil.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilRef = 0x00;
- depthStencil.back.stencilFunc = XGL_COMPARE_ALWAYS;
- depthStencil.front = depthStencil.back;
+ depthStencil.stencilBackRef = 0;
+ depthStencil.stencilFrontRef = 0;
+ depthStencil.stencilReadMask = 0xff;
+ depthStencil.stencilWriteMask = 0xff;
- err = xglCreateDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
+ err = xglCreateDynamicDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
ASSERT_XGL_SUCCESS( err );
/* create image view */
@@ -858,7 +854,7 @@
att.blendEnable = XGL_FALSE;
att.format = m_render_target_fmt;
att.channelWriteMask = 0xf;
- pipelineobj.SetColorAttachment(1, &att);
+ pipelineobj.AddColorAttachment(1, &att);
XglCommandBufferObj cmdBuffer(m_device);
@@ -1762,6 +1758,21 @@
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
+ XGL_PIPELINE_DS_STATE_CREATE_INFO ds_state;
+ ds_state.depthTestEnable = XGL_TRUE;
+ ds_state.depthWriteEnable = XGL_TRUE;
+ ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL;
+ ds_state.depthBoundsEnable = XGL_FALSE;
+ ds_state.stencilTestEnable = XGL_FALSE;
+ ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS;
+ ds_state.format.channelFormat = XGL_CH_FMT_R32;
+ ds_state.format.numericFormat = XGL_NUM_FMT_DS;
+ ds_state.front = ds_state.back;
+ pipelineobj.SetDepthStencil(&ds_state);
+
XglDescriptorSetObj descriptorSet(m_device);
descriptorSet.AttachBufferView(&MVPBuffer);
@@ -2617,6 +2628,21 @@
pipelineobj.AddVertexInputAttribs(vi_attribs,2);
pipelineobj.AddVertexDataBuffer(&meshBuffer,0);
+ XGL_PIPELINE_DS_STATE_CREATE_INFO ds_state;
+ ds_state.depthTestEnable = XGL_TRUE;
+ ds_state.depthWriteEnable = XGL_TRUE;
+ ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL;
+ ds_state.depthBoundsEnable = XGL_FALSE;
+ ds_state.stencilTestEnable = XGL_FALSE;
+ ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
+ ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS;
+ ds_state.format.channelFormat = XGL_CH_FMT_R32;
+ ds_state.format.numericFormat = XGL_NUM_FMT_DS;
+ ds_state.front = ds_state.back;
+ pipelineobj.SetDepthStencil(&ds_state);
+
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
XglCommandBufferObj cmdBuffer(m_device);
cmdBuffer.AddRenderTarget(m_renderTargets[0]);
diff --git a/tests/xglrenderframework.cpp b/tests/xglrenderframework.cpp
index c144ac4..ef1a949 100644
--- a/tests/xglrenderframework.cpp
+++ b/tests/xglrenderframework.cpp
@@ -33,7 +33,6 @@
m_colorBlend( XGL_NULL_HANDLE ),
m_stateViewport( XGL_NULL_HANDLE ),
m_stateDepthStencil( XGL_NULL_HANDLE ),
- m_stateMsaa( XGL_NULL_HANDLE ),
m_width( 256.0 ), // default window width
m_height( 256.0 ) // default window height
{
@@ -42,7 +41,6 @@
m_render_target_fmt.channelFormat = XGL_CH_FMT_R8G8B8A8;
m_render_target_fmt.numericFormat = XGL_NUM_FMT_UNORM;
- m_colorBindings[0].view = XGL_NULL_HANDLE;
m_depthStencilBinding.view = XGL_NULL_HANDLE;
}
@@ -67,7 +65,6 @@
void XglRenderFramework::ShutdownFramework()
{
if (m_colorBlend) xglDestroyObject(m_colorBlend);
- if (m_stateMsaa) xglDestroyObject(m_stateMsaa);
if (m_stateDepthStencil) xglDestroyObject(m_stateDepthStencil);
if (m_stateRaster) xglDestroyObject(m_stateRaster);
if (m_cmdBuffer) xglDestroyObject(m_cmdBuffer);
@@ -76,14 +73,6 @@
xglDestroyObject(m_stateViewport);
}
- for (XGL_UINT i = 0; i < m_renderTargetCount; i++) {
- if (m_renderTargets[i]) {
- // TODO: XglImage should be able to destroy itself
-// m_renderTarget->
-// xglDestroyObject(*m_renderTarget);
- }
- }
-
// reset the driver
delete m_device;
xglInitAndEnumerateGpus(&this->app_info, XGL_NULL_HANDLE, 0, &gpu_count, XGL_NULL_HANDLE);
@@ -97,43 +86,26 @@
m_render_target_fmt.numericFormat = XGL_NUM_FMT_UNORM;
// create a raster state (solid, back-face culling)
- XGL_RASTER_STATE_CREATE_INFO raster = {};
- raster.sType = XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO;
- raster.fillMode = XGL_FILL_SOLID;
- raster.cullMode = XGL_CULL_NONE;
- raster.frontFace = XGL_FRONT_FACE_CCW;
- err = xglCreateRasterState( device(), &raster, &m_stateRaster );
+ XGL_DYNAMIC_RS_STATE_CREATE_INFO raster = {};
+ raster.sType = XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO;
+ raster.pointSize = 1.0;
+
+ err = xglCreateDynamicRasterState( device(), &raster, &m_stateRaster );
ASSERT_XGL_SUCCESS(err);
- XGL_COLOR_BLEND_STATE_CREATE_INFO blend = {};
- blend.sType = XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO;
- err = xglCreateColorBlendState(device(), &blend, &m_colorBlend);
+ XGL_DYNAMIC_CB_STATE_CREATE_INFO blend = {};
+ blend.sType = XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO;
+ err = xglCreateDynamicColorBlendState(device(), &blend, &m_colorBlend);
ASSERT_XGL_SUCCESS( err );
- XGL_DEPTH_STENCIL_STATE_CREATE_INFO depthStencil = {};
- depthStencil.sType = XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO;
- depthStencil.depthTestEnable = XGL_FALSE;
- depthStencil.depthWriteEnable = XGL_FALSE;
- depthStencil.depthFunc = XGL_COMPARE_LESS_EQUAL;
- depthStencil.depthBoundsEnable = XGL_FALSE;
+ XGL_DYNAMIC_DS_STATE_CREATE_INFO depthStencil = {};
+ depthStencil.sType = XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
depthStencil.minDepth = 0.f;
depthStencil.maxDepth = 1.f;
- depthStencil.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
- depthStencil.back.stencilRef = 0x00;
- depthStencil.back.stencilFunc = XGL_COMPARE_ALWAYS;
- depthStencil.front = depthStencil.back;
+ depthStencil.stencilFrontRef = 0;
+ depthStencil.stencilBackRef = 0;
- err = xglCreateDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
- ASSERT_XGL_SUCCESS( err );
-
- XGL_MSAA_STATE_CREATE_INFO msaa = {};
- msaa.sType = XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO;
- msaa.sampleMask = 1;
- msaa.samples = 1;
-
- err = xglCreateMsaaState( device(), &msaa, &m_stateMsaa );
+ err = xglCreateDynamicDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
ASSERT_XGL_SUCCESS( err );
XGL_CMD_BUFFER_CREATE_INFO cmdInfo = {};
@@ -148,17 +120,21 @@
{
XGL_RESULT err;
- XGL_VIEWPORT_STATE_CREATE_INFO viewport = {};
- viewport.viewportCount = 1;
- viewport.scissorEnable = XGL_FALSE;
- viewport.viewports[0].originX = 0;
- viewport.viewports[0].originY = 0;
- viewport.viewports[0].width = 1.f * width;
- viewport.viewports[0].height = 1.f * height;
- viewport.viewports[0].minDepth = 0.f;
- viewport.viewports[0].maxDepth = 1.f;
+ XGL_VIEWPORT viewport;
- err = xglCreateViewportState( device(), &viewport, &m_stateViewport );
+ XGL_DYNAMIC_VP_STATE_CREATE_INFO viewportCreate = {};
+ viewportCreate.sType = XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO;
+ viewportCreate.viewportCount = 1;
+ viewportCreate.scissorCount = 0;
+ viewport.originX = 0;
+ viewport.originY = 0;
+ viewport.width = 1.f * width;
+ viewport.height = 1.f * height;
+ viewport.minDepth = 0.f;
+ viewport.maxDepth = 1.f;
+ viewportCreate.pViewports = &viewport;
+
+ err = xglCreateDynamicViewportState( device(), &viewportCreate, &m_stateViewport );
ASSERT_XGL_SUCCESS( err );
m_width = width;
m_height = height;
@@ -178,9 +154,9 @@
img->init(m_width, m_height, m_render_target_fmt,
XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT |
XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
- m_renderTargets[i] = img;
- m_colorBindings[i].view = m_renderTargets[i]->targetView();
+ m_colorBindings[i].view = img->targetView();
m_colorBindings[i].colorAttachmentState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL;
+ m_renderTargets.push_back(img);
}
// Create Framebuffer and RenderPass with color attachments and any depth/stencil attachment
XGL_ATTACHMENT_LOAD_OP load_op = XGL_ATTACHMENT_LOAD_OP_LOAD;
@@ -722,14 +698,16 @@
stageInfo->sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stageInfo->shader.stage = m_stage;
stageInfo->shader.shader = obj();
- stageInfo->shader.descriptorSetMapping[0].descriptorCount = 0;
+ stageInfo->shader.descriptorSetMappingCount = 1;
+ stageInfo->shader.pDescriptorSetMapping = (XGL_DESCRIPTOR_SET_MAPPING *)malloc(sizeof(XGL_DESCRIPTOR_SET_MAPPING));
+ stageInfo->shader.pDescriptorSetMapping->descriptorCount = 0;
stageInfo->shader.linkConstBufferCount = 0;
stageInfo->shader.pLinkConstBufferInfo = XGL_NULL_HANDLE;
stageInfo->shader.dynamicBufferViewMapping.slotObjectType = XGL_SLOT_UNUSED;
stageInfo->shader.dynamicBufferViewMapping.shaderEntityIndex = 0;
- stageInfo->shader.descriptorSetMapping[0].descriptorCount = descriptorSet->GetTotalSlots();
- if (stageInfo->shader.descriptorSetMapping[0].descriptorCount)
+ stageInfo->shader.pDescriptorSetMapping->descriptorCount = descriptorSet->GetTotalSlots();
+ if (stageInfo->shader.pDescriptorSetMapping->descriptorCount)
{
vector<int> allSlots;
vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> allTypes;
@@ -759,7 +737,7 @@
}
slotInfo = descriptorSet->GetSlotInfo(allSlots, allTypes, allObjs);
- stageInfo->shader.descriptorSetMapping[0].pDescriptorInfo = (const XGL_DESCRIPTOR_SLOT_INFO*) slotInfo;
+ stageInfo->shader.pDescriptorSetMapping[0].pDescriptorInfo = (const XGL_DESCRIPTOR_SLOT_INFO*) slotInfo;
}
return stageInfo;
}
@@ -841,7 +819,6 @@
m_ia_state.pNext = XGL_NULL_HANDLE;
m_ia_state.topology = XGL_TOPOLOGY_TRIANGLE_LIST;
m_ia_state.disableVertexReuse = XGL_FALSE;
- m_ia_state.provokingVertex = XGL_PROVOKING_VERTEX_LAST;
m_ia_state.primitiveRestartEnable = XGL_FALSE;
m_ia_state.primitiveRestartIndex = 0;
@@ -849,7 +826,10 @@
m_rs_state.pNext = &m_ia_state;
m_rs_state.depthClipEnable = XGL_FALSE;
m_rs_state.rasterizerDiscardEnable = XGL_FALSE;
- m_rs_state.pointSize = 1.0;
+ m_rs_state.provokingVertex = XGL_PROVOKING_VERTEX_LAST;
+ m_rs_state.fillMode = XGL_FILL_SOLID;
+ m_rs_state.cullMode = XGL_CULL_NONE;
+ m_rs_state.frontFace = XGL_FRONT_FACE_CCW;
memset(&m_cb_state,0,sizeof(m_cb_state));
m_cb_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
@@ -858,16 +838,35 @@
m_cb_state.dualSourceBlendEnable = XGL_FALSE;
m_cb_state.logicOp = XGL_LOGIC_OP_COPY;
- m_cb_state.attachment[0].blendEnable = XGL_FALSE;
- m_cb_state.attachment[0].format.channelFormat = XGL_CH_FMT_R8G8B8A8;
- m_cb_state.attachment[0].format.numericFormat = XGL_NUM_FMT_UNORM;
- m_cb_state.attachment[0].channelWriteMask = 0xF;
+ m_ms_state.pNext = &m_cb_state;
+ m_ms_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO;
+ m_ms_state.multisampleEnable = XGL_FALSE;
+ m_ms_state.sampleMask = 1; // Do we have to specify MSAA even just to disable it?
+ m_ms_state.samples = 1;
+ m_ms_state.minSampleShading = 0;
+ m_ms_state.sampleShadingEnable = 0;
- m_db_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO,
- m_db_state.pNext = &m_cb_state,
- m_db_state.format.channelFormat = XGL_CH_FMT_R32;
- m_db_state.format.numericFormat = XGL_NUM_FMT_DS;
+ m_ds_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
+ m_ds_state.pNext = &m_ms_state,
+ m_ds_state.format.channelFormat = XGL_CH_FMT_R32;
+ m_ds_state.format.numericFormat = XGL_NUM_FMT_DS;
+ m_ds_state.depthTestEnable = XGL_FALSE;
+ m_ds_state.depthWriteEnable = XGL_FALSE;
+ m_ds_state.depthBoundsEnable = XGL_FALSE;
+ m_ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL;
+ m_ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
+ m_ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
+ m_ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
+ m_ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS;
+ m_ds_state.stencilTestEnable = XGL_FALSE;
+ m_ds_state.front = m_ds_state.back;
+ XGL_PIPELINE_CB_ATTACHMENT_STATE att = {};
+ att.blendEnable = XGL_FALSE;
+ att.format.channelFormat = XGL_CH_FMT_R8G8B8A8;
+ att.format.numericFormat = XGL_NUM_FMT_UNORM;
+ att.channelWriteMask = 0xf;
+ AddColorAttachment(0, &att);
};
@@ -895,14 +894,30 @@
m_vertexBufferCount++;
}
-void XglPipelineObj::SetColorAttachment(XGL_UINT binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att)
+void XglPipelineObj::AddColorAttachment(XGL_UINT binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att)
{
- m_cb_state.attachment[binding] = *att;
+ if (binding+1 > m_colorAttachments.size())
+ {
+ m_colorAttachments.resize(binding+1);
+ }
+ m_colorAttachments[binding] = *att;
+}
+
+void XglPipelineObj::SetDepthStencil(XGL_PIPELINE_DS_STATE_CREATE_INFO *ds_state)
+{
+ m_ds_state.format = ds_state->format;
+ m_ds_state.depthTestEnable = ds_state->depthTestEnable;
+ m_ds_state.depthWriteEnable = ds_state->depthWriteEnable;
+ m_ds_state.depthBoundsEnable = ds_state->depthBoundsEnable;
+ m_ds_state.depthFunc = ds_state->depthFunc;
+ m_ds_state.stencilTestEnable = ds_state->stencilTestEnable;
+ m_ds_state.back = ds_state->back;
+ m_ds_state.front = ds_state->front;
}
void XglPipelineObj::CreateXGLPipeline(XglDescriptorSetObj *descriptorSet)
{
- XGL_VOID* head_ptr = &m_db_state;
+ XGL_VOID* head_ptr = &m_ds_state;
XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
@@ -925,6 +940,9 @@
info.pNext = head_ptr;
info.flags = 0;
+ m_cb_state.attachmentCount = m_colorAttachments.size();
+ m_cb_state.pAttachments = &m_colorAttachments[0];
+
init(*m_device, info);
}
@@ -935,7 +953,7 @@
void XglPipelineObj::BindPipelineCommandBuffer(XGL_CMD_BUFFER m_cmdBuffer, XglDescriptorSetObj *descriptorSet)
{
- XGL_VOID* head_ptr = &m_db_state;
+ XGL_VOID* head_ptr = &m_ds_state;
XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
@@ -1125,9 +1143,9 @@
}
}
-void XglCommandBufferObj::BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT stateObject)
+void XglCommandBufferObj::BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject)
{
- xglCmdBindStateObject( obj(), stateBindPoint, stateObject);
+ xglCmdBindDynamicStateObject( obj(), stateBindPoint, stateObject);
}
void XglCommandBufferObj::AddRenderTarget(XglImage *renderTarget)
diff --git a/tests/xglrenderframework.h b/tests/xglrenderframework.h
index 421f79d..13f1eb7 100644
--- a/tests/xglrenderframework.h
+++ b/tests/xglrenderframework.h
@@ -64,24 +64,23 @@
protected:
- XGL_APPLICATION_INFO app_info;
- XGL_PHYSICAL_GPU objs[XGL_MAX_PHYSICAL_GPUS];
- XGL_UINT gpu_count;
- XglDevice *m_device;
- XGL_CMD_BUFFER m_cmdBuffer;
- XGL_RENDER_PASS m_renderPass;
- XGL_MEMORY_REF m_memRefs[5];
- XGL_RASTER_STATE_OBJECT m_stateRaster;
- XGL_COLOR_BLEND_STATE_OBJECT m_colorBlend;
- XGL_VIEWPORT_STATE_OBJECT m_stateViewport;
- XGL_DEPTH_STENCIL_STATE_OBJECT m_stateDepthStencil;
- XGL_MSAA_STATE_OBJECT m_stateMsaa;
- XglImage *m_renderTargets[XGL_MAX_COLOR_ATTACHMENTS];
- XGL_UINT m_renderTargetCount;
- XGL_FLOAT m_width, m_height;
- XGL_FORMAT m_render_target_fmt;
- XGL_COLOR_ATTACHMENT_BIND_INFO m_colorBindings[XGL_MAX_COLOR_ATTACHMENTS];
- XGL_DEPTH_STENCIL_BIND_INFO m_depthStencilBinding;
+ XGL_APPLICATION_INFO app_info;
+ XGL_PHYSICAL_GPU objs[XGL_MAX_PHYSICAL_GPUS];
+ XGL_UINT gpu_count;
+ XglDevice *m_device;
+ XGL_CMD_BUFFER m_cmdBuffer;
+ XGL_RENDER_PASS m_renderPass;
+ XGL_MEMORY_REF m_memRefs[5];
+ XGL_DYNAMIC_RS_STATE_OBJECT m_stateRaster;
+ XGL_DYNAMIC_CB_STATE_OBJECT m_colorBlend;
+ XGL_DYNAMIC_VP_STATE_OBJECT m_stateViewport;
+ XGL_DYNAMIC_DS_STATE_OBJECT m_stateDepthStencil;
+ vector<XglImage*> m_renderTargets;
+ XGL_UINT m_renderTargetCount;
+ XGL_FLOAT m_width, m_height;
+ XGL_FORMAT m_render_target_fmt;
+ XGL_COLOR_ATTACHMENT_BIND_INFO m_colorBindings[8];
+ XGL_DEPTH_STENCIL_BIND_INFO m_depthStencilBinding;
/*
* SetUp and TearDown are called by the Google Test framework
@@ -126,7 +125,7 @@
void BindDescriptorSet(XGL_DESCRIPTOR_SET descriptorSet);
void BindVertexBuffer(XglConstantBufferObj *vertexBuffer, XGL_UINT offset, XGL_UINT binding);
void BindIndexBuffer(XglIndexBufferObj *indexBuffer, XGL_UINT offset);
- void BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT stateObject);
+ void BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject);
void Draw(XGL_UINT firstVertex, XGL_UINT vertexCount, XGL_UINT firstInstance, XGL_UINT instanceCount);
void DrawIndexed(XGL_UINT firstIndex, XGL_UINT indexCount, XGL_INT vertexOffset, XGL_UINT firstInstance, XGL_UINT instanceCount);
void QueueCommandBuffer(XGL_MEMORY_REF *memRefs, XGL_UINT32 numMemRefs);
@@ -316,7 +315,8 @@
void AddVertexInputAttribs(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count);
void AddVertexInputBindings(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count);
void AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding);
- void SetColorAttachment(XGL_UINT binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att);
+ void AddColorAttachment(XGL_UINT binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att);
+ void SetDepthStencil(XGL_PIPELINE_DS_STATE_CREATE_INFO *);
void CreateXGLPipeline(XglDescriptorSetObj *descriptorSet);
XGL_PIPELINE GetPipelineHandle();
@@ -324,12 +324,14 @@
XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_vi_state;
XGL_PIPELINE_IA_STATE_CREATE_INFO m_ia_state;
XGL_PIPELINE_RS_STATE_CREATE_INFO m_rs_state;
- XGL_PIPELINE_CB_STATE m_cb_state;
- XGL_PIPELINE_DB_STATE_CREATE_INFO m_db_state;
+ XGL_PIPELINE_CB_STATE_CREATE_INFO m_cb_state;
+ XGL_PIPELINE_DS_STATE_CREATE_INFO m_ds_state;
+ XGL_PIPELINE_MS_STATE_CREATE_INFO m_ms_state;
XglDevice *m_device;
vector<XglShaderObj*> m_shaderObjs;
vector<XglConstantBufferObj*> m_vertexBufferObjs;
vector<int> m_vertexBufferBindings;
+ vector<XGL_PIPELINE_CB_ATTACHMENT_STATE> m_colorAttachments;
int m_vertexBufferCount;
};
diff --git a/tests/xgltestbinding.cpp b/tests/xgltestbinding.cpp
index b738734..3c2b386 100644
--- a/tests/xgltestbinding.cpp
+++ b/tests/xgltestbinding.cpp
@@ -260,21 +260,25 @@
const std::vector<XGL_MEMORY_REQUIREMENTS> mem_reqs = memory_requirements();
for (int i = 0; i < mem_reqs.size(); i++) {
XGL_MEMORY_ALLOC_INFO info = GpuMemory::alloc_info(mem_reqs[i]);
+ std::vector<uint32_t> heap_ids;
// prefer CPU visible heaps
std::vector<uint32_t> non_visible_heaps;
info.heapCount = 0;
for (uint32_t j = 0; j < mem_reqs[i].heapCount; j++) {
- const uint32_t heap = mem_reqs[i].heaps[j];
+ const uint32_t heap = mem_reqs[i].pHeaps[j];
const XGL_MEMORY_HEAP_PROPERTIES &props = dev.heap_properties()[heap];
if (props.flags & XGL_MEMORY_HEAP_CPU_VISIBLE_BIT)
- info.heaps[info.heapCount++] = heap;
+ heap_ids.push_back(heap);
else
non_visible_heaps.push_back(heap);
}
for (std::vector<uint32_t>::const_iterator it = non_visible_heaps.begin(); it != non_visible_heaps.end(); it++)
- info.heaps[info.heapCount++] = *it;
+ heap_ids.push_back(*it);
+
+ info.heapCount = heap_ids.size();
+ info.pHeaps = &heap_ids[0];
primary_mem_ = &internal_mems_[i];
@@ -408,8 +412,6 @@
uint32_t count;
if (!EXPECT(xglGetMemoryHeapCount(obj(), &count) == XGL_SUCCESS && count))
return;
- if (count > XGL_MAX_MEMORY_HEAPS)
- count = XGL_MAX_MEMORY_HEAPS;
heap_props_.reserve(count);
for (uint32_t i = 0; i < count; i++) {
@@ -789,33 +791,27 @@
xglAttachNestedDescriptors(obj(), start_slot, sets.size(), &sets[0]);
}
-void DynamicVpStateObject::init(const Device &dev, const XGL_VIEWPORT_STATE_CREATE_INFO &info)
+void DynamicVpStateObject::init(const Device &dev, const XGL_DYNAMIC_VP_STATE_CREATE_INFO &info)
{
- DERIVED_OBJECT_INIT(xglCreateViewportState, dev.obj(), &info);
+ DERIVED_OBJECT_INIT(xglCreateDynamicViewportState, dev.obj(), &info);
alloc_memory(dev);
}
-void DynamicRsStateObject::init(const Device &dev, const XGL_RASTER_STATE_CREATE_INFO &info)
+void DynamicRsStateObject::init(const Device &dev, const XGL_DYNAMIC_RS_STATE_CREATE_INFO &info)
{
- DERIVED_OBJECT_INIT(xglCreateRasterState, dev.obj(), &info);
+ DERIVED_OBJECT_INIT(xglCreateDynamicRasterState, dev.obj(), &info);
alloc_memory(dev);
}
-void DynamicMsaaStateObject::init(const Device &dev, const XGL_MSAA_STATE_CREATE_INFO &info)
+void DynamicCbStateObject::init(const Device &dev, const XGL_DYNAMIC_CB_STATE_CREATE_INFO &info)
{
- DERIVED_OBJECT_INIT(xglCreateMsaaState, dev.obj(), &info);
+ DERIVED_OBJECT_INIT(xglCreateDynamicColorBlendState, dev.obj(), &info);
alloc_memory(dev);
}
-void DynamicCbStateObject::init(const Device &dev, const XGL_COLOR_BLEND_STATE_CREATE_INFO &info)
+void DynamicDsStateObject::init(const Device &dev, const XGL_DYNAMIC_DS_STATE_CREATE_INFO &info)
{
- DERIVED_OBJECT_INIT(xglCreateColorBlendState, dev.obj(), &info);
- alloc_memory(dev);
-}
-
-void DynamicDsStateObject::init(const Device &dev, const XGL_DEPTH_STENCIL_STATE_CREATE_INFO &info)
-{
- DERIVED_OBJECT_INIT(xglCreateDepthStencilState, dev.obj(), &info);
+ DERIVED_OBJECT_INIT(xglCreateDynamicDepthStencilState, dev.obj(), &info);
alloc_memory(dev);
}
diff --git a/tests/xgltestbinding.h b/tests/xgltestbinding.h
index a06ba16..88f15ae 100644
--- a/tests/xgltestbinding.h
+++ b/tests/xgltestbinding.h
@@ -171,11 +171,11 @@
class DynamicStateObject : public Object {
public:
- const XGL_STATE_OBJECT &obj() const { return reinterpret_cast<const XGL_STATE_OBJECT &>(Object::obj()); }
+ const XGL_DYNAMIC_STATE_OBJECT &obj() const { return reinterpret_cast<const XGL_DYNAMIC_STATE_OBJECT &>(Object::obj()); }
protected:
explicit DynamicStateObject() {}
- explicit DynamicStateObject(XGL_STATE_OBJECT obj) : Object(obj) {}
+ explicit DynamicStateObject(XGL_DYNAMIC_STATE_OBJECT obj) : Object(obj) {}
};
template<typename T, class C>
@@ -542,34 +542,28 @@
XGL_DESCRIPTOR_SET_CREATE_INFO info_;
};
-class DynamicVpStateObject : public DerivedObject<XGL_VIEWPORT_STATE_OBJECT, DynamicStateObject> {
+class DynamicVpStateObject : public DerivedObject<XGL_DYNAMIC_VP_STATE_OBJECT, DynamicStateObject> {
public:
- // xglCreateViewportState()
- void init(const Device &dev, const XGL_VIEWPORT_STATE_CREATE_INFO &info);
+ // xglCreateDynamicViewportState()
+ void init(const Device &dev, const XGL_DYNAMIC_VP_STATE_CREATE_INFO &info);
};
-class DynamicRsStateObject : public DerivedObject<XGL_RASTER_STATE_OBJECT, DynamicStateObject> {
+class DynamicRsStateObject : public DerivedObject<XGL_DYNAMIC_RS_STATE_OBJECT, DynamicStateObject> {
public:
- // xglCreateRasterState()
- void init(const Device &dev, const XGL_RASTER_STATE_CREATE_INFO &info);
+ // xglCreateDynamicRasterState()
+ void init(const Device &dev, const XGL_DYNAMIC_RS_STATE_CREATE_INFO &info);
};
-class DynamicMsaaStateObject : public DerivedObject<XGL_MSAA_STATE_OBJECT, DynamicStateObject> {
+class DynamicCbStateObject : public DerivedObject<XGL_DYNAMIC_CB_STATE_OBJECT, DynamicStateObject> {
public:
- // xglCreateMsaaState()
- void init(const Device &dev, const XGL_MSAA_STATE_CREATE_INFO &info);
+ // xglCreateDynamicColorBlendState()
+ void init(const Device &dev, const XGL_DYNAMIC_CB_STATE_CREATE_INFO &info);
};
-class DynamicCbStateObject : public DerivedObject<XGL_COLOR_BLEND_STATE_OBJECT, DynamicStateObject> {
+class DynamicDsStateObject : public DerivedObject<XGL_DYNAMIC_DS_STATE_OBJECT, DynamicStateObject> {
public:
- // xglCreateColorBlendState()
- void init(const Device &dev, const XGL_COLOR_BLEND_STATE_CREATE_INFO &info);
-};
-
-class DynamicDsStateObject : public DerivedObject<XGL_DEPTH_STENCIL_STATE_OBJECT, DynamicStateObject> {
-public:
- // xglCreateDepthStencilState()
- void init(const Device &dev, const XGL_DEPTH_STENCIL_STATE_CREATE_INFO &info);
+ // xglCreateDynamicDepthStencilState()
+ void init(const Device &dev, const XGL_DYNAMIC_DS_STATE_CREATE_INFO &info);
};
class CmdBuffer : public DerivedObject<XGL_CMD_BUFFER, Object> {
@@ -616,8 +610,7 @@
info.allocationSize = reqs.size;
info.alignment = reqs.alignment;
info.heapCount = reqs.heapCount;
- for (int i = 0; i < reqs.heapCount; i++)
- info.heaps[i] = reqs.heaps[i];
+ info.pHeaps = reqs.pHeaps;
info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
return info;
}