XGL_PIPELINE pipeline;
- XGL_VIEWPORT_STATE_OBJECT viewport;
- XGL_RASTER_STATE_OBJECT raster;
- XGL_MSAA_STATE_OBJECT msaa;
- XGL_COLOR_BLEND_STATE_OBJECT color_blend;
- XGL_DEPTH_STENCIL_STATE_OBJECT depth_stencil;
+ XGL_DYNAMIC_VP_STATE_OBJECT viewport;
+ XGL_DYNAMIC_RS_STATE_OBJECT raster;
+ XGL_DYNAMIC_CB_STATE_OBJECT color_blend;
+ XGL_DYNAMIC_DS_STATE_OBJECT depth_stencil;
mat4x4 projection_matrix;
mat4x4 view_matrix;
xglCmdBindDescriptorSet(demo->cmd, XGL_PIPELINE_BIND_POINT_GRAPHICS,
0, demo->dset, 0);
- xglCmdBindStateObject(demo->cmd, XGL_STATE_BIND_VIEWPORT, demo->viewport);
- xglCmdBindStateObject(demo->cmd, XGL_STATE_BIND_RASTER, demo->raster);
- xglCmdBindStateObject(demo->cmd, XGL_STATE_BIND_MSAA, demo->msaa);
- xglCmdBindStateObject(demo->cmd, XGL_STATE_BIND_COLOR_BLEND,
+ xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_VIEWPORT, demo->viewport);
+ xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_RASTER, demo->raster);
+ xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_COLOR_BLEND,
demo->color_blend);
- xglCmdBindStateObject(demo->cmd, XGL_STATE_BIND_DEPTH_STENCIL,
+ xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_DEPTH_STENCIL,
demo->depth_stencil);
clear_range.aspect = XGL_IMAGE_ASPECT_COLOR;
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);
+ XGL_UINT heapInfo[1];
+ mem_alloc.pHeaps = (const XGL_UINT *)&heapInfo;
+ memcpy(&heapInfo, mem_reqs.pHeaps,
+ sizeof(mem_reqs.pHeaps[0]) * mem_reqs.heapCount);
/* allocate memory */
err = xglAllocMemory(demo->device, &mem_alloc,
.alignment = 0,
.flags = 0,
.heapCount = 0,
+ .pHeaps = 0,
.memPriority = XGL_MEMORY_PRIORITY_NORMAL,
};
XGL_IMAGE_VIEW_CREATE_INFO view = {
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);
+ XGL_UINT heapInfo[1];
+ mem_alloc.pHeaps = (const XGL_UINT *)&heapInfo;
+ memcpy(&heapInfo, mem_reqs.pHeaps,
+ sizeof(mem_reqs.pHeaps[0]) * mem_reqs.heapCount);
/* allocate memory */
err = xglAllocMemory(demo->device, &mem_alloc,
alloc_info.allocationSize = mem_reqs.size;
alloc_info.alignment = mem_reqs.alignment;
alloc_info.heapCount = mem_reqs.heapCount;
- memcpy(alloc_info.heaps, mem_reqs.heaps,
- sizeof(mem_reqs.heaps[0]) * mem_reqs.heapCount);
+ XGL_UINT heapInfo[1];
+ alloc_info.pHeaps = (const XGL_UINT *)&heapInfo;
+ memcpy(&heapInfo, mem_reqs.pHeaps,
+ sizeof(mem_reqs.pHeaps[0]) * mem_reqs.heapCount);
alloc_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
err = xglAllocMemory(demo->device, &alloc_info, &demo->uniform_data.mem);
XGL_GRAPHICS_PIPELINE_CREATE_INFO pipeline;
XGL_PIPELINE_IA_STATE_CREATE_INFO ia;
XGL_PIPELINE_RS_STATE_CREATE_INFO rs;
- XGL_PIPELINE_CB_STATE cb;
- XGL_PIPELINE_DB_STATE_CREATE_INFO db;
+ XGL_PIPELINE_CB_STATE_CREATE_INFO cb;
+ XGL_PIPELINE_DS_STATE_CREATE_INFO ds;
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO vs;
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO fs;
+ XGL_PIPELINE_VP_STATE_CREATE_INFO vp;
+ XGL_PIPELINE_MS_STATE_CREATE_INFO ms;
XGL_DESCRIPTOR_SLOT_INFO vs_slots[3];
XGL_DESCRIPTOR_SLOT_INFO fs_slots[3];
XGL_RESULT err;
memset(&rs, 0, sizeof(rs));
rs.sType = XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO;
+ rs.fillMode = XGL_FILL_SOLID;
+ rs.cullMode = XGL_CULL_NONE;
+ rs.frontFace = XGL_FRONT_FACE_CCW;
memset(&cb, 0, sizeof(cb));
cb.sType = XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
- cb.attachment[0].format = demo->format;
- cb.attachment[0].channelWriteMask = 0xf;
-
- memset(&db, 0, sizeof(db));
- db.sType = XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO;
- db.format = demo->depth.format;
+ XGL_PIPELINE_CB_ATTACHMENT_STATE att_state[1];
+ memset(att_state, 0, sizeof(att_state));
+ att_state[0].format = demo->format;
+ att_state[0].channelWriteMask = 0xf;
+ att_state[0].blendEnable = XGL_FALSE;
+ cb.attachmentCount = 1;
+ cb.pAttachments = att_state;
+
+ memset(&vp, 0, sizeof(vp));
+ vp.sType = XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO;
+ vp.scissorEnable = XGL_FALSE;
+
+ memset(&ds, 0, sizeof(ds));
+ ds.sType = XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
+ ds.format = demo->depth.format;
+ ds.depthTestEnable = XGL_TRUE;
+ ds.depthWriteEnable = XGL_TRUE;
+ ds.depthFunc = XGL_COMPARE_LESS_EQUAL;
+ ds.depthBoundsEnable = XGL_FALSE;
+ ds.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
+ ds.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
+ ds.back.stencilFunc = XGL_COMPARE_ALWAYS;
+ ds.stencilTestEnable = XGL_FALSE;
+ ds.front = ds.back;
memset(&vs_slots, 0, sizeof(vs_slots));
vs_slots[0].slotObjectType = XGL_SLOT_SHADER_RESOURCE;
vs.shader.stage = XGL_SHADER_STAGE_VERTEX;
vs.shader.shader = demo_prepare_vs(demo);
assert(vs.shader.shader != NULL);
- vs.shader.descriptorSetMapping[0].descriptorCount = 3;
- vs.shader.descriptorSetMapping[0].pDescriptorInfo = vs_slots;
+ XGL_DESCRIPTOR_SET_MAPPING ds_mapping1;
+ ds_mapping1.descriptorCount = 3;
+ ds_mapping1.pDescriptorInfo = vs_slots;
+ vs.shader.pDescriptorSetMapping = &ds_mapping1;
+ vs.shader.linkConstBufferCount = 0;
+ vs.shader.descriptorSetMappingCount = 1;
memset(&fs, 0, sizeof(fs));
fs.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
fs.shader.stage = XGL_SHADER_STAGE_FRAGMENT;
fs.shader.shader = demo_prepare_fs(demo);
assert(fs.shader.shader != NULL);
- fs.shader.descriptorSetMapping[0].descriptorCount = 3;
- fs.shader.descriptorSetMapping[0].pDescriptorInfo = fs_slots;
+ XGL_DESCRIPTOR_SET_MAPPING ds_mapping2;
+ ds_mapping2.descriptorCount = 3;
+ ds_mapping2.pDescriptorInfo = fs_slots;
+ fs.shader.pDescriptorSetMapping = &ds_mapping2;
+ fs.shader.linkConstBufferCount = 0;
+ fs.shader.descriptorSetMappingCount = 1;
+
+ memset(&ms, 0, sizeof(ms));
+ ms.sType = XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO;
+ ms.sampleMask = 1;
+ ms.multisampleEnable = XGL_FALSE;
+ ms.samples = 1;
pipeline.pNext = (const XGL_VOID *) &ia;
ia.pNext = (const XGL_VOID *) &rs;
rs.pNext = (const XGL_VOID *) &cb;
- cb.pNext = (const XGL_VOID *) &db;
- db.pNext = (const XGL_VOID *) &vs;
+ cb.pNext = (const XGL_VOID *) &ms;
+ ms.pNext = (const XGL_VOID *) &vp;
+ vp.pNext = (const XGL_VOID *) &ds;
+ ds.pNext = (const XGL_VOID *) &vs;
vs.pNext = (const XGL_VOID *) &fs;
err = xglCreateGraphicsPipeline(demo->device, &pipeline, &demo->pipeline);
static void demo_prepare_dynamic_states(struct demo *demo)
{
- XGL_VIEWPORT_STATE_CREATE_INFO viewport;
- XGL_RASTER_STATE_CREATE_INFO raster;
- XGL_MSAA_STATE_CREATE_INFO msaa;
- XGL_COLOR_BLEND_STATE_CREATE_INFO color_blend;
- XGL_DEPTH_STENCIL_STATE_CREATE_INFO depth_stencil;
+ XGL_DYNAMIC_VP_STATE_CREATE_INFO viewport_create;
+ XGL_DYNAMIC_RS_STATE_CREATE_INFO raster;
+ XGL_DYNAMIC_CB_STATE_CREATE_INFO color_blend;
+ XGL_DYNAMIC_DS_STATE_CREATE_INFO depth_stencil;
XGL_RESULT err;
- memset(&viewport, 0, sizeof(viewport));
- viewport.viewportCount = 1;
- viewport.scissorEnable = XGL_FALSE;
- viewport.viewports[0].width = (XGL_FLOAT) demo->width;
- viewport.viewports[0].height = (XGL_FLOAT) demo->height;
- viewport.viewports[0].minDepth = (XGL_FLOAT) 0.0f;
- viewport.viewports[0].maxDepth = (XGL_FLOAT) 1.0f;
+ memset(&viewport_create, 0, sizeof(viewport_create));
+ viewport_create.sType = XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO;
+ viewport_create.viewportCount = 1;
+ XGL_VIEWPORT viewport;
+ viewport.height = (XGL_FLOAT) demo->height;
+ viewport.width = (XGL_FLOAT) demo->width;
+ viewport.minDepth = (XGL_FLOAT) 0.0f;
+ viewport.maxDepth = (XGL_FLOAT) 1.0f;
+ viewport_create.pViewports = &viewport;
memset(&raster, 0, sizeof(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;
-
- memset(&msaa, 0, sizeof(msaa));
- msaa.sType = XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO;
- msaa.samples = 1;
- msaa.sampleMask = 0x1;
+ raster.sType = XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO;
memset(&color_blend, 0, sizeof(color_blend));
- color_blend.sType = XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO;
+ color_blend.sType = XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO;
memset(&depth_stencil, 0, sizeof(depth_stencil));
- depth_stencil.sType = XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO;
- depth_stencil.depthTestEnable = XGL_TRUE;
- depth_stencil.depthWriteEnable = XGL_TRUE;
- depth_stencil.depthFunc = XGL_COMPARE_LESS_EQUAL;
- depth_stencil.depthBoundsEnable = XGL_FALSE;
-
- err = xglCreateViewportState(demo->device, &viewport, &demo->viewport);
- assert(!err);
+ depth_stencil.sType = XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
+ depth_stencil.stencilBackRef = 0;
+ depth_stencil.stencilFrontRef = 0;
+ depth_stencil.stencilReadMask = 0xff;
+ depth_stencil.stencilWriteMask = 0xff;
- err = xglCreateRasterState(demo->device, &raster, &demo->raster);
+ err = xglCreateDynamicViewportState(demo->device, &viewport_create, &demo->viewport);
assert(!err);
- err = xglCreateMsaaState(demo->device, &msaa, &demo->msaa);
+ err = xglCreateDynamicRasterState(demo->device, &raster, &demo->raster);
assert(!err);
- err = xglCreateColorBlendState(demo->device,
+ err = xglCreateDynamicColorBlendState(demo->device,
&color_blend, &demo->color_blend);
assert(!err);
- err = xglCreateDepthStencilState(demo->device,
+ err = xglCreateDynamicDepthStencilState(demo->device,
&depth_stencil, &demo->depth_stencil);
assert(!err);
}
xglDestroyObject(demo->viewport);
xglDestroyObject(demo->raster);
- xglDestroyObject(demo->msaa);
xglDestroyObject(demo->color_blend);
xglDestroyObject(demo->depth_stencil);
XGL_PIPELINE pipeline;
- XGL_VIEWPORT_STATE_OBJECT viewport;
- XGL_RASTER_STATE_OBJECT raster;
- XGL_MSAA_STATE_OBJECT msaa;
- XGL_COLOR_BLEND_STATE_OBJECT color_blend;
- XGL_DEPTH_STENCIL_STATE_OBJECT depth_stencil;
+ XGL_DYNAMIC_VP_STATE_OBJECT viewport;
+ XGL_DYNAMIC_RS_STATE_OBJECT raster;
+ XGL_DYNAMIC_CB_STATE_OBJECT color_blend;
+ XGL_DYNAMIC_DS_STATE_OBJECT depth_stencil;
XGL_CMD_BUFFER cmd;
xglCmdBindDescriptorSet(demo->cmd, XGL_PIPELINE_BIND_POINT_GRAPHICS,
0, demo->dset, 0);
- xglCmdBindStateObject(demo->cmd, XGL_STATE_BIND_VIEWPORT, demo->viewport);
- xglCmdBindStateObject(demo->cmd, XGL_STATE_BIND_RASTER, demo->raster);
- xglCmdBindStateObject(demo->cmd, XGL_STATE_BIND_MSAA, demo->msaa);
- xglCmdBindStateObject(demo->cmd, XGL_STATE_BIND_COLOR_BLEND,
+ xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_VIEWPORT, demo->viewport);
+ xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_RASTER, demo->raster);
+ xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_COLOR_BLEND,
demo->color_blend);
- xglCmdBindStateObject(demo->cmd, XGL_STATE_BIND_DEPTH_STENCIL,
+ xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_DEPTH_STENCIL,
demo->depth_stencil);
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);
+ XGL_UINT heapInfo[1];
+ mem_alloc.pHeaps = (const XGL_UINT *)&heapInfo;
+ memcpy(&heapInfo, mem_reqs.pHeaps,
+ sizeof(mem_reqs.pHeaps[0]) * mem_reqs.heapCount);
/* allocate memory */
err = xglAllocMemory(demo->device, &mem_alloc,
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);
+ XGL_UINT heapInfo[0];
+ mem_alloc.pHeaps = (const XGL_UINT *)&heapInfo;
+ memcpy(&heapInfo, mem_reqs.pHeaps,
+ sizeof(mem_reqs.pHeaps[0]) * mem_reqs.heapCount);
/* allocate memory */
err = xglAllocMemory(demo->device, &mem_alloc,
.alignment = 0,
.flags = 0,
.heapCount = 0,
- .heaps[0] = 0,
+ .pHeaps = 0,
.memPriority = XGL_MEMORY_PRIORITY_NORMAL,
};
XGL_MEMORY_REQUIREMENTS mem_reqs;
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 = mem_reqs.pHeaps;
+ memcpy((XGL_UINT *)mem_alloc.pHeaps, mem_reqs.pHeaps,
+ sizeof(mem_reqs.pHeaps[0]) * mem_reqs.heapCount);
err = xglAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem);
assert(!err);
XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO vi;
XGL_PIPELINE_IA_STATE_CREATE_INFO ia;
XGL_PIPELINE_RS_STATE_CREATE_INFO rs;
- XGL_PIPELINE_CB_STATE cb;
- XGL_PIPELINE_DB_STATE_CREATE_INFO db;
+ XGL_PIPELINE_CB_STATE_CREATE_INFO cb;
+ XGL_PIPELINE_DS_STATE_CREATE_INFO ds;
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO vs;
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO fs;
+ XGL_PIPELINE_VP_STATE_CREATE_INFO vp;
+ XGL_PIPELINE_MS_STATE_CREATE_INFO ms;
XGL_DESCRIPTOR_SLOT_INFO fs_slots[DEMO_TEXTURE_COUNT * 2];
XGL_RESULT err;
XGL_UINT i;
memset(&rs, 0, sizeof(rs));
rs.sType = XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO;
+ rs.fillMode = XGL_FILL_SOLID;
+ rs.cullMode = XGL_CULL_NONE;
+ rs.frontFace = XGL_FRONT_FACE_CCW;
memset(&cb, 0, sizeof(cb));
cb.sType = XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
- cb.attachment[0].format = demo->format;
- cb.attachment[0].channelWriteMask = 0xf;
-
- memset(&db, 0, sizeof(db));
- db.sType = XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO;
- db.format = demo->depth.format;
+ XGL_PIPELINE_CB_ATTACHMENT_STATE att_state[1];
+ memset(att_state, 0, sizeof(att_state));
+ att_state[0].format = demo->format;
+ att_state[0].channelWriteMask = 0xf;
+ att_state[0].blendEnable = XGL_FALSE;
+ cb.attachmentCount = 1;
+ cb.pAttachments = att_state;
+
+
+ memset(&vp, 0, sizeof(vp));
+ vp.sType = XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO;
+ vp.scissorEnable = XGL_FALSE;
+
+
+ memset(&ds, 0, sizeof(ds));
+ ds.sType = XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
+ ds.format = demo->depth.format;
+ ds.depthTestEnable = XGL_TRUE;
+ ds.depthWriteEnable = XGL_TRUE;
+ ds.depthFunc = XGL_COMPARE_LESS_EQUAL;
+ ds.depthBoundsEnable = XGL_FALSE;
+ ds.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
+ ds.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
+ ds.back.stencilFunc = XGL_COMPARE_ALWAYS;
+ ds.stencilTestEnable = XGL_FALSE;
+ ds.front = ds.back;
memset(&fs_slots, 0, sizeof(fs_slots));
for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
vs.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
vs.shader.stage = XGL_SHADER_STAGE_VERTEX;
vs.shader.shader = demo_prepare_vs(demo);
+ vs.shader.linkConstBufferCount = 0;
+ vs.shader.descriptorSetMappingCount = 0;
memset(&fs, 0, sizeof(fs));
fs.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
fs.shader.stage = XGL_SHADER_STAGE_FRAGMENT;
fs.shader.shader = demo_prepare_fs(demo);
- fs.shader.descriptorSetMapping[0].descriptorCount =
- DEMO_TEXTURE_COUNT * 2;
- fs.shader.descriptorSetMapping[0].pDescriptorInfo = fs_slots;
+ XGL_DESCRIPTOR_SET_MAPPING ds_mapping;
+ ds_mapping.descriptorCount = DEMO_TEXTURE_COUNT * 2;
+ ds_mapping.pDescriptorInfo = fs_slots;
+ fs.shader.descriptorSetMappingCount = 1;
+ fs.shader.pDescriptorSetMapping = &ds_mapping;
+
+ memset(&ms, 0, sizeof(ms));
+ ms.sType = XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO;
+ ms.sampleMask = 1;
+ ms.multisampleEnable = XGL_FALSE;
+ ms.samples = 1;
pipeline.pNext = (const XGL_VOID *) &vi;
vi.pNext = (XGL_VOID *) &ia;
ia.pNext = (const XGL_VOID *) &rs;
rs.pNext = (const XGL_VOID *) &cb;
- cb.pNext = (const XGL_VOID *) &db;
- db.pNext = (const XGL_VOID *) &vs;
+ cb.pNext = (const XGL_VOID *) &ms;
+ ms.pNext = (const XGL_VOID *) &vp;
+ vp.pNext = (const XGL_VOID *) &ds;
+ ds.pNext = (const XGL_VOID *) &vs;
vs.pNext = (const XGL_VOID *) &fs;
err = xglCreateGraphicsPipeline(demo->device, &pipeline, &demo->pipeline);
static void demo_prepare_dynamic_states(struct demo *demo)
{
- XGL_VIEWPORT_STATE_CREATE_INFO viewport;
- XGL_RASTER_STATE_CREATE_INFO raster;
- XGL_MSAA_STATE_CREATE_INFO msaa;
- XGL_COLOR_BLEND_STATE_CREATE_INFO color_blend;
- XGL_DEPTH_STENCIL_STATE_CREATE_INFO depth_stencil;
+ XGL_DYNAMIC_VP_STATE_CREATE_INFO viewport_create;
+ XGL_DYNAMIC_RS_STATE_CREATE_INFO raster;
+ XGL_DYNAMIC_CB_STATE_CREATE_INFO color_blend;
+ XGL_DYNAMIC_DS_STATE_CREATE_INFO depth_stencil;
XGL_RESULT err;
+ memset(&viewport_create, 0, sizeof(viewport_create));
+ viewport_create.sType = XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO;
+ viewport_create.viewportCount = 1;
+ XGL_VIEWPORT viewport;
memset(&viewport, 0, sizeof(viewport));
- viewport.viewportCount = 1;
- viewport.scissorEnable = XGL_FALSE;
- viewport.viewports[0].width = (XGL_FLOAT) demo->width;
- viewport.viewports[0].height = (XGL_FLOAT) demo->height;
- viewport.viewports[0].minDepth = (XGL_FLOAT) 0.0f;
- viewport.viewports[0].maxDepth = (XGL_FLOAT) 1.0f;
+ viewport.width = (XGL_FLOAT) demo->width;
+ viewport.height = (XGL_FLOAT) demo->height;
+ viewport.minDepth = (XGL_FLOAT) 0.0f;
+ viewport.maxDepth = (XGL_FLOAT) 1.0f;
+ viewport_create.pViewports = &viewport;
memset(&raster, 0, sizeof(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;
-
- memset(&msaa, 0, sizeof(msaa));
- msaa.sType = XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO;
- msaa.samples = 1;
- msaa.sampleMask = 0x1;
+ raster.sType = XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO;
memset(&color_blend, 0, sizeof(color_blend));
- color_blend.sType = XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO;
+ color_blend.sType = XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO;
memset(&depth_stencil, 0, sizeof(depth_stencil));
- depth_stencil.sType = XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO;
- depth_stencil.depthTestEnable = XGL_TRUE;
- depth_stencil.depthWriteEnable = XGL_TRUE;
- depth_stencil.depthFunc = XGL_COMPARE_LESS_EQUAL;
- depth_stencil.depthBoundsEnable = XGL_FALSE;
-
- err = xglCreateViewportState(demo->device, &viewport, &demo->viewport);
- assert(!err);
+ depth_stencil.sType = XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
+ depth_stencil.stencilBackRef = 0;
+ depth_stencil.stencilFrontRef = 0;
+ depth_stencil.stencilReadMask = 0xff;
+ depth_stencil.stencilWriteMask = 0xff;
- err = xglCreateRasterState(demo->device, &raster, &demo->raster);
+ err = xglCreateDynamicViewportState(demo->device, &viewport_create, &demo->viewport);
assert(!err);
- err = xglCreateMsaaState(demo->device, &msaa, &demo->msaa);
+ err = xglCreateDynamicRasterState(demo->device, &raster, &demo->raster);
assert(!err);
- err = xglCreateColorBlendState(demo->device,
+ err = xglCreateDynamicColorBlendState(demo->device,
&color_blend, &demo->color_blend);
assert(!err);
- err = xglCreateDepthStencilState(demo->device,
+ err = xglCreateDynamicDepthStencilState(demo->device,
&depth_stencil, &demo->depth_stencil);
assert(!err);
}
xglDestroyObject(demo->viewport);
xglDestroyObject(demo->raster);
- xglDestroyObject(demo->msaa);
xglDestroyObject(demo->color_blend);
xglDestroyObject(demo->depth_stencil);
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_STATE_OBJECT, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_VIEWPORT_STATE_OBJECT, XGL_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_RASTER_STATE_OBJECT, XGL_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_MSAA_STATE_OBJECT, XGL_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_COLOR_BLEND_STATE_OBJECT, XGL_STATE_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEPTH_STENCIL_STATE_OBJECT, XGL_STATE_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_STATE_OBJECT, XGL_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_VP_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_RS_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_CB_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DYNAMIC_DS_STATE_OBJECT, XGL_DYNAMIC_STATE_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_CMD_BUFFER, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_FENCE, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUEUE_SEMAPHORE, XGL_OBJECT)
#define XGL_MAX_PHYSICAL_GPUS 16
#define XGL_MAX_PHYSICAL_GPU_NAME 256
-#define XGL_MAX_MEMORY_HEAPS 8
-#define XGL_MAX_DESCRIPTOR_SETS 2
-#define XGL_MAX_VIEWPORTS 16
-#define XGL_MAX_COLOR_ATTACHMENTS 8
#define XGL_LOD_CLAMP_NONE MAX_FLOAT
#define XGL_LAST_MIP_OR_SLICE 0xffffffff
{
XGL_STATE_BIND_VIEWPORT = 0x00000000,
XGL_STATE_BIND_RASTER = 0x00000001,
- XGL_STATE_BIND_DEPTH_STENCIL = 0x00000002,
- XGL_STATE_BIND_COLOR_BLEND = 0x00000003,
- XGL_STATE_BIND_MSAA = 0x00000004,
+ XGL_STATE_BIND_COLOR_BLEND = 0x00000002,
+ XGL_STATE_BIND_DEPTH_STENCIL = 0x00000003,
XGL_STATE_BIND_POINT_BEGIN_RANGE = XGL_STATE_BIND_VIEWPORT,
- XGL_STATE_BIND_POINT_END_RANGE = XGL_STATE_BIND_MSAA,
+ XGL_STATE_BIND_POINT_END_RANGE = XGL_STATE_BIND_DEPTH_STENCIL,
XGL_NUM_STATE_BIND_POINT = (XGL_STATE_BIND_POINT_END_RANGE - XGL_STATE_BIND_POINT_BEGIN_RANGE + 1),
XGL_MAX_ENUM(_XGL_STATE_BIND_POINT)
} XGL_STATE_BIND_POINT;
XGL_MAX_ENUM(_XGL_FACE_ORIENTATION)
} XGL_FACE_ORIENTATION;
+typedef enum _XGL_PROVOKING_VERTEX_CONVENTION
+{
+ XGL_PROVOKING_VERTEX_FIRST = 0x00000000,
+ XGL_PROVOKING_VERTEX_LAST = 0x00000001,
+
+ XGL_PROVOKING_VERTEX_BEGIN_RANGE = XGL_PROVOKING_VERTEX_FIRST,
+ XGL_PROVOKING_VERTEX_END_RANGE = XGL_PROVOKING_VERTEX_LAST,
+ XGL_NUM_PROVOKING_VERTEX_CONVENTION = (XGL_PROVOKING_VERTEX_END_RANGE - XGL_PROVOKING_VERTEX_BEGIN_RANGE + 1),
+ XGL_MAX_ENUM(_XGL_PROVOKING_VERTEX_CONVENTION)
+} XGL_PROVOKING_VERTEX_CONVENTION;
+
+typedef enum _XGL_COORDINATE_ORIGIN
+{
+ XGL_COORDINATE_ORIGIN_UPPER_LEFT = 0x00000000,
+ XGL_COORDINATE_ORIGIN_LOWER_LEFT = 0x00000001,
+
+ XGL_COORDINATE_ORIGIN_BEGIN_RANGE = XGL_COORDINATE_ORIGIN_UPPER_LEFT,
+ XGL_COORDINATE_ORIGIN_END_RANGE = XGL_COORDINATE_ORIGIN_LOWER_LEFT,
+ XGL_NUM_COORDINATE_ORIGIN = (XGL_COORDINATE_ORIGIN_END_RANGE - XGL_COORDINATE_ORIGIN_END_RANGE + 1),
+ XGL_MAX_ENUM(_XGL_COORDINATE_ORIGIN)
+} XGL_COORDINATE_ORIGIN;
+
+typedef enum _XGL_DEPTH_MODE
+{
+ XGL_DEPTH_MODE_ZERO_TO_ONE = 0x00000000,
+ XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE = 0x00000001,
+
+ XGL_DEPTH_MODE_BEGIN_RANGE = XGL_DEPTH_MODE_ZERO_TO_ONE,
+ XGL_DEPTH_MODE_END_RANGE = XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE,
+ XGL_NUM_DEPTH_MODE = (XGL_DEPTH_MODE_END_RANGE - XGL_DEPTH_MODE_BEGIN_RANGE + 1),
+ XGL_MAX_ENUM(_XGL_DEPTH_MODE)
+} XGL_DEPTH_MODE;
+
typedef enum _XGL_BLEND
{
XGL_BLEND_ZERO = 0x00000000,
XGL_MAX_ENUM(_XGL_NUM_FORMAT)
} XGL_NUM_FORMAT;
-typedef enum _XGL_PROVOKING_VERTEX_CONVENTION
-{
- XGL_PROVOKING_VERTEX_FIRST = 0,
- XGL_PROVOKING_VERTEX_LAST = 1,
-
- XGL_PROVOKING_VERTEX_BEGIN_RANGE = XGL_PROVOKING_VERTEX_FIRST,
- XGL_PROVOKING_VERTEX_END_RANGE = XGL_PROVOKING_VERTEX_LAST,
- XGL_NUM_PROVOKING_VERTEX_CONVENTIONS = (XGL_PROVOKING_VERTEX_END_RANGE - XGL_PROVOKING_VERTEX_BEGIN_RANGE + 1),
- XGL_MAX_ENUM(_XGL_PROVOKING_VERTEX_CONVENTION)
-} XGL_PROVOKING_VERTEX_CONVENTION;
-
// IMG CHANGE BEGIN - support for vertex input description
typedef enum _XGL_VERTEX_INPUT_STEP_RATE
{
XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 13,
XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 14,
XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO = 15,
- XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO = 16,
- XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO = 17,
- XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO = 18,
- XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO = 19,
+ XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO = 16,
+ XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO = 17,
+ XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO = 18,
+ XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO = 19,
XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 20,
XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO = 21,
XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO = 22,
XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 25,
XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 26,
XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 27,
- XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 28,
- XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO = 29,
- XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 30,
- XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 31,
- XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 32,
- XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 33,
+ XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 28,
+ XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 29,
+ XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 30,
+ XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO = 31,
+ XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 32,
+ XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO = 33,
+ XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 34,
+ XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO = 35,
+ XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 36,
XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 37,
XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 38,
XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 39,
XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 41,
XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 42,
XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO = 43,
-// IMG CHANGE BEGIN - support for vertex input description
- XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 90,
-// IMG CHANGE END
XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
} XGL_STRUCTURE_TYPE;
XGL_UINT maxThreadGroupSize;
XGL_UINT64 timestampFrequency;
XGL_BOOL multiColorAttachmentClears;
+ XGL_UINT maxMemoryHeaps; // at least 8?
+ XGL_UINT maxDescriptorSets; // at least 2?
+ XGL_UINT maxViewports; // at least 16?
+ XGL_UINT maxColorAttachments; // at least 8?
} XGL_PHYSICAL_GPU_PROPERTIES;
typedef struct _XGL_PHYSICAL_GPU_PERFORMANCE
XGL_GPU_SIZE alignment;
XGL_FLAGS flags; // XGL_MEMORY_ALLOC_FLAGS
XGL_UINT heapCount;
- XGL_UINT heaps[XGL_MAX_MEMORY_HEAPS];
+ const XGL_UINT* pHeaps;
XGL_MEMORY_PRIORITY memPriority;
} XGL_MEMORY_ALLOC_INFO;
XGL_GPU_SIZE alignment; // Specified in bytes
XGL_GPU_SIZE granularity; // Granularity on which xglBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size)
XGL_UINT heapCount;
- XGL_UINT heaps[XGL_MAX_MEMORY_HEAPS];
+ XGL_UINT* pHeaps;
} XGL_MEMORY_REQUIREMENTS;
typedef struct _XGL_FORMAT_PROPERTIES
{
XGL_PIPELINE_SHADER_STAGE stage;
XGL_SHADER shader;
- XGL_DESCRIPTOR_SET_MAPPING descriptorSetMapping[XGL_MAX_DESCRIPTOR_SETS];
+ XGL_UINT descriptorSetMappingCount;
+ XGL_DESCRIPTOR_SET_MAPPING* pDescriptorSetMapping;
XGL_UINT linkConstBufferCount;
const XGL_LINK_CONST_BUFFER* pLinkConstBufferInfo;
XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO dynamicBufferViewMapping;
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
XGL_PRIMITIVE_TOPOLOGY topology;
- XGL_BOOL disableVertexReuse;
- XGL_PROVOKING_VERTEX_CONVENTION provokingVertex;
+ XGL_BOOL disableVertexReuse; //optional
XGL_BOOL primitiveRestartEnable;
- XGL_UINT32 primitiveRestartIndex;
+ XGL_UINT32 primitiveRestartIndex; //optional (GL45)
} XGL_PIPELINE_IA_STATE_CREATE_INFO;
typedef struct _XGL_PIPELINE_TESS_STATE_CREATE_INFO
XGL_FLOAT fixedTessFactor;
} XGL_PIPELINE_TESS_STATE_CREATE_INFO;
+typedef struct _XGL_PIPELINE_VP_STATE_CREATE_INFO
+{
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO
+ const void* pNext; // Pointer to next structure
+ XGL_UINT numViewports;
+ XGL_UINT scissorEnable;
+ XGL_COORDINATE_ORIGIN clipOrigin; // optional (GL45)
+ XGL_DEPTH_MODE depthMode; // optional (GL45)
+} XGL_PIPELINE_VP_STATE_CREATE_INFO;
+
typedef struct _XGL_PIPELINE_RS_STATE_CREATE_INFO
{
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
XGL_BOOL depthClipEnable;
XGL_BOOL rasterizerDiscardEnable;
- XGL_FLOAT pointSize; // Size of points
+ XGL_BOOL programPointSize; // optional (GL45)
+ XGL_COORDINATE_ORIGIN pointOrigin; // optional (GL45)
+ XGL_PROVOKING_VERTEX_CONVENTION provokingVertex; // optional (GL45)
+ XGL_FILL_MODE fillMode; // optional (GL45)
+ XGL_CULL_MODE cullMode;
+ XGL_FACE_ORIENTATION frontFace;
} XGL_PIPELINE_RS_STATE_CREATE_INFO;
+typedef struct _XGL_PIPELINE_MS_STATE_CREATE_INFO
+{
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO
+ const XGL_VOID* pNext; // Pointer to next structure
+ XGL_UINT samples;
+ XGL_BOOL multisampleEnable; // optional (GL45)
+ XGL_BOOL sampleShadingEnable; // optional (GL45)
+ XGL_FLOAT minSampleShading; // optional (GL45)
+ XGL_SAMPLE_MASK sampleMask;
+} XGL_PIPELINE_MS_STATE_CREATE_INFO;
+
typedef struct _XGL_PIPELINE_CB_ATTACHMENT_STATE
{
XGL_BOOL blendEnable;
XGL_FORMAT format;
+ XGL_BLEND srcBlendColor;
+ XGL_BLEND destBlendColor;
+ XGL_BLEND_FUNC blendFuncColor;
+ XGL_BLEND srcBlendAlpha;
+ XGL_BLEND destBlendAlpha;
+ XGL_BLEND_FUNC blendFuncAlpha;
XGL_UINT8 channelWriteMask;
} XGL_PIPELINE_CB_ATTACHMENT_STATE;
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
XGL_BOOL alphaToCoverageEnable;
- XGL_BOOL dualSourceBlendEnable;
+ XGL_BOOL dualSourceBlendEnable; // optional (GL45)
+ XGL_BOOL logicOpEnable;
XGL_LOGIC_OP logicOp;
- XGL_PIPELINE_CB_ATTACHMENT_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
-} XGL_PIPELINE_CB_STATE;
+ XGL_UINT attachmentCount; // # of pAttachments
+ XGL_PIPELINE_CB_ATTACHMENT_STATE* pAttachments;
+} XGL_PIPELINE_CB_STATE_CREATE_INFO;
-typedef struct _XGL_PIPELINE_DB_STATE_CREATE_INFO
+typedef struct _XGL_STENCIL_OP_STATE
{
- XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
- const XGL_VOID* pNext; // Pointer to next structure
- XGL_FORMAT format;
-} XGL_PIPELINE_DB_STATE_CREATE_INFO;
+ XGL_STENCIL_OP stencilFailOp;
+ XGL_STENCIL_OP stencilPassOp;
+ XGL_STENCIL_OP stencilDepthFailOp;
+ XGL_COMPARE_FUNC stencilFunc;
+} XGL_STENCIL_OP_STATE;
+
+typedef struct _XGL_PIPELINE_DS_STATE_CREATE_INFO
+{
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO
+ const void* pNext; // Pointer to next structure
+ XGL_FORMAT format;
+ XGL_BOOL depthTestEnable;
+ XGL_BOOL depthWriteEnable;
+ XGL_COMPARE_FUNC depthFunc;
+ XGL_BOOL depthBoundsEnable; // optional (depth_bounds_test)
+ XGL_BOOL stencilTestEnable;
+ XGL_STENCIL_OP_STATE front;
+ XGL_STENCIL_OP_STATE back;
+} XGL_PIPELINE_DS_STATE_CREATE_INFO;
+
typedef struct _XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
{
{
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
- XGL_UINT slots;
+ XGL_UINT slots;
} XGL_DESCRIPTOR_SET_CREATE_INFO;
typedef struct _XGL_DESCRIPTOR_SET_ATTACH_INFO
XGL_UINT slotOffset;
} XGL_DESCRIPTOR_SET_ATTACH_INFO;
-typedef struct _XGL_VIEWPORT_STATE_CREATE_INFO
+typedef struct _XGL_DYNAMIC_VP_STATE_CREATE_INFO
{
- XGL_UINT viewportCount;
- XGL_BOOL scissorEnable;
- XGL_VIEWPORT viewports[XGL_MAX_VIEWPORTS];
- XGL_RECT scissors[XGL_MAX_VIEWPORTS];
-} XGL_VIEWPORT_STATE_CREATE_INFO;
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO
+ const void* pNext; // Pointer to next structure
+ XGL_UINT viewportCount; // number of entries in pViewports
+ XGL_VIEWPORT* pViewports;
+ XGL_UINT scissorCount; // number of entries in pScissors
+ XGL_RECT* pScissors;
+} XGL_DYNAMIC_VP_STATE_CREATE_INFO;
-typedef struct _XGL_RASTER_STATE_CREATE_INFO
+typedef struct _XGL_DYNAMIC_RS_STATE_CREATE_INFO
{
- XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
- XGL_FILL_MODE fillMode;
- XGL_CULL_MODE cullMode;
- XGL_FACE_ORIENTATION frontFace;
- XGL_INT depthBias;
+ XGL_FLOAT depthBias;
XGL_FLOAT depthBiasClamp;
XGL_FLOAT slopeScaledDepthBias;
-} XGL_RASTER_STATE_CREATE_INFO;
+ XGL_FLOAT pointSize; // optional (GL45) - Size of point
+ XGL_FLOAT pointFadeThreshold; // optional (GL45) - Size of point fade threshold
+ XGL_FLOAT lineWidth; // optional (GL45) - Width of lines
+} XGL_DYNAMIC_RS_STATE_CREATE_INFO;
typedef struct _XGL_MSAA_STATE_CREATE_INFO
{
XGL_SAMPLE_MASK sampleMask;
} XGL_MSAA_STATE_CREATE_INFO;
-typedef struct _XGL_COLOR_ATTACHMENT_BLEND_STATE
-{
- XGL_BOOL blendEnable;
- XGL_BLEND srcBlendColor;
- XGL_BLEND destBlendColor;
- XGL_BLEND_FUNC blendFuncColor;
- XGL_BLEND srcBlendAlpha;
- XGL_BLEND destBlendAlpha;
- XGL_BLEND_FUNC blendFuncAlpha;
-} XGL_COLOR_ATTACHMENT_BLEND_STATE;
-
-typedef struct _XGL_COLOR_BLEND_STATE_CREATE_INFO
+typedef struct _XGL_DYNAMIC_CB_STATE_CREATE_INFO
{
- XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
- XGL_COLOR_ATTACHMENT_BLEND_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
XGL_FLOAT blendConst[4];
-} XGL_COLOR_BLEND_STATE_CREATE_INFO;
-
-typedef struct _XGL_STENCIL_OP_STATE
-{
- XGL_STENCIL_OP stencilFailOp;
- XGL_STENCIL_OP stencilPassOp;
- XGL_STENCIL_OP stencilDepthFailOp;
- XGL_COMPARE_FUNC stencilFunc;
- XGL_UINT32 stencilRef;
-} XGL_STENCIL_OP_STATE;
+} XGL_DYNAMIC_CB_STATE_CREATE_INFO;
-typedef struct _XGL_DEPTH_STENCIL_STATE_CREATE_INFO
+typedef struct _XGL_DYNAMIC_DS_STATE_CREATE_INFO
{
- XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO
+ XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
- XGL_BOOL depthTestEnable;
- XGL_BOOL depthWriteEnable;
- XGL_COMPARE_FUNC depthFunc;
- XGL_BOOL depthBoundsEnable;
- XGL_FLOAT minDepth;
- XGL_FLOAT maxDepth;
- XGL_BOOL stencilTestEnable;
+ XGL_FLOAT minDepth; // optional (depth_bounds_test)
+ XGL_FLOAT maxDepth; // optional (depth_bounds_test)
XGL_UINT32 stencilReadMask;
XGL_UINT32 stencilWriteMask;
- XGL_STENCIL_OP_STATE front;
- XGL_STENCIL_OP_STATE back;
-} XGL_DEPTH_STENCIL_STATE_CREATE_INFO;
+ XGL_UINT32 stencilFrontRef;
+ XGL_UINT32 stencilBackRef;
+} XGL_DYNAMIC_DS_STATE_CREATE_INFO;
typedef struct _XGL_CMD_BUFFER_CREATE_INFO
{
typedef XGL_VOID (XGLAPI *xglAttachBufferViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferViews);
typedef XGL_VOID (XGLAPI *xglAttachNestedDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
typedef XGL_VOID (XGLAPI *xglClearDescriptorSetSlotsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount);
-typedef XGL_RESULT (XGLAPI *xglCreateViewportStateType)(XGL_DEVICE device, const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo, XGL_VIEWPORT_STATE_OBJECT* pState);
-typedef XGL_RESULT (XGLAPI *xglCreateRasterStateType)(XGL_DEVICE device, const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo, XGL_RASTER_STATE_OBJECT* pState);
-typedef XGL_RESULT (XGLAPI *xglCreateMsaaStateType)(XGL_DEVICE device, const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo, XGL_MSAA_STATE_OBJECT* pState);
-typedef XGL_RESULT (XGLAPI *xglCreateColorBlendStateType)(XGL_DEVICE device, const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo, XGL_COLOR_BLEND_STATE_OBJECT* pState);
-typedef XGL_RESULT (XGLAPI *xglCreateDepthStencilStateType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *xglCreateDynamicViewportStateType)(XGL_DEVICE device, const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_VP_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *xglCreateDynamicRasterStateType)(XGL_DEVICE device, const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_RS_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *xglCreateDynamicColorBlendStateType)(XGL_DEVICE device, const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_CB_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *xglCreateDynamicDepthStencilStateType)(XGL_DEVICE device, const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, XGL_DYNAMIC_DS_STATE_OBJECT* pState);
typedef XGL_RESULT (XGLAPI *xglCreateCommandBufferType)(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer);
typedef XGL_RESULT (XGLAPI *xglBeginCommandBufferType)(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo);
typedef XGL_RESULT (XGLAPI *xglEndCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
typedef XGL_RESULT (XGLAPI *xglResetCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
typedef XGL_VOID (XGLAPI *xglCmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline);
typedef XGL_VOID (XGLAPI *xglCmdBindPipelineDeltaType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta);
-typedef XGL_VOID (XGLAPI *xglCmdBindStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT state);
+typedef XGL_VOID (XGLAPI *xglCmdBindDynamicStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state);
typedef XGL_VOID (XGLAPI *xglCmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT index, XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT slotOffset);
typedef XGL_VOID (XGLAPI *xglCmdBindDynamicBufferViewType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferView);
typedef XGL_VOID (XGLAPI *xglCmdBindVertexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT binding);
// State object functions
-XGL_RESULT XGLAPI xglCreateViewportState(
- XGL_DEVICE device,
- const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
- XGL_VIEWPORT_STATE_OBJECT* pState);
-
-XGL_RESULT XGLAPI xglCreateRasterState(
+XGL_RESULT XGLAPI xglCreateDynamicViewportState(
XGL_DEVICE device,
- const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
- XGL_RASTER_STATE_OBJECT* pState);
+ const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_VP_STATE_OBJECT* pState);
-XGL_RESULT XGLAPI xglCreateMsaaState(
+XGL_RESULT XGLAPI xglCreateDynamicRasterState(
XGL_DEVICE device,
- const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
- XGL_MSAA_STATE_OBJECT* pState);
+ const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_RS_STATE_OBJECT* pState);
-XGL_RESULT XGLAPI xglCreateColorBlendState(
+XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(
XGL_DEVICE device,
- const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
- XGL_COLOR_BLEND_STATE_OBJECT* pState);
+ const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_CB_STATE_OBJECT* pState);
-XGL_RESULT XGLAPI xglCreateDepthStencilState(
+XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(
XGL_DEVICE device,
- const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
- XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
+ const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_DS_STATE_OBJECT* pState);
// Command buffer functions
XGL_PIPELINE_BIND_POINT pipelineBindPoint,
XGL_PIPELINE_DELTA delta);
-XGL_VOID XGLAPI xglCmdBindStateObject(
+XGL_VOID XGLAPI xglCmdBindDynamicStateObject(
XGL_CMD_BUFFER cmdBuffer,
XGL_STATE_BIND_POINT stateBindPoint,
- XGL_STATE_OBJECT state);
+ XGL_DYNAMIC_STATE_OBJECT dynamicState);
XGL_VOID XGLAPI xglCmdBindDescriptorSet(
XGL_CMD_BUFFER cmdBuffer,
xglAttachBufferViewDescriptorsType AttachBufferViewDescriptors;
xglAttachNestedDescriptorsType AttachNestedDescriptors;
xglClearDescriptorSetSlotsType ClearDescriptorSetSlots;
- xglCreateViewportStateType CreateViewportState;
- xglCreateRasterStateType CreateRasterState;
- xglCreateMsaaStateType CreateMsaaState;
- xglCreateColorBlendStateType CreateColorBlendState;
- xglCreateDepthStencilStateType CreateDepthStencilState;
+ xglCreateDynamicViewportStateType CreateDynamicViewportState;
+ xglCreateDynamicRasterStateType CreateDynamicRasterState;
+ xglCreateDynamicColorBlendStateType CreateDynamicColorBlendState;
+ xglCreateDynamicDepthStencilStateType CreateDynamicDepthStencilState;
xglCreateCommandBufferType CreateCommandBuffer;
xglBeginCommandBufferType BeginCommandBuffer;
xglEndCommandBufferType EndCommandBuffer;
xglResetCommandBufferType ResetCommandBuffer;
xglCmdBindPipelineType CmdBindPipeline;
xglCmdBindPipelineDeltaType CmdBindPipelineDelta;
- xglCmdBindStateObjectType CmdBindStateObject;
+ xglCmdBindDynamicStateObjectType CmdBindDynamicStateObject;
xglCmdBindDescriptorSetType CmdBindDescriptorSet;
xglCmdBindDynamicBufferViewType CmdBindDynamicBufferView;
xglCmdBindVertexBufferType CmdBindVertexBuffer;
"XGL_IMAGE_VIEW" : "XGL_OBJECT_TYPE_IMAGE_VIEW",
"XGL_COLOR_ATTACHMENT_VIEW" : "XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW",
"XGL_DEPTH_STENCIL_VIEW" : "XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW",
- "XGL_VIEWPORT_STATE_OBJECT" : "XGL_OBJECT_TYPE_VIEWPORT_STATE",
- "XGL_RASTER_STATE_OBJECT" : "XGL_OBJECT_TYPE_RASTER_STATE",
+ "XGL_DYNAMIC_VP_STATE_OBJECT" : "XGL_OBJECT_TYPE_VIEWPORT_STATE",
+ "XGL_DYNAMIC_RS_STATE_OBJECT" : "XGL_OBJECT_TYPE_RASTER_STATE",
"XGL_MSAA_STATE_OBJECT" : "XGL_OBJECT_TYPE_MSAA_STATE",
- "XGL_COLOR_BLEND_STATE_OBJECT" : "XGL_OBJECT_TYPE_COLOR_BLEND_STATE",
- "XGL_DEPTH_STENCIL_STATE_OBJECT" : "XGL_OBJECT_TYPE_DEPTH_STENCIL_STATE",
+ "XGL_DYNAMIC_CB_STATE_OBJECT" : "XGL_OBJECT_TYPE_COLOR_BLEND_STATE",
+ "XGL_DYNAMIC_DS_STATE_OBJECT" : "XGL_OBJECT_TYPE_DEPTH_STENCIL_STATE",
"XGL_BASE_OBJECT" : "ll_get_obj_type(object)",
"XGL_OBJECT" : "ll_get_obj_type(object)"
}
"XGL_PIPELINE_DELTA",
"XGL_SAMPLER",
"XGL_DESCRIPTOR_SET",
- "XGL_STATE_OBJECT",
- "XGL_VIEWPORT_STATE_OBJECT",
- "XGL_RASTER_STATE_OBJECT",
- "XGL_MSAA_STATE_OBJECT",
- "XGL_COLOR_BLEND_STATE_OBJECT",
- "XGL_DEPTH_STENCIL_STATE_OBJECT",
+ "XGL_DYNAMIC_STATE_OBJECT",
+ "XGL_DYNAMIC_VP_STATE_OBJECT",
+ "XGL_DYNAMIC_RS_STATE_OBJECT",
+ "XGL_DYNAMIC_CB_STATE_OBJECT",
+ "XGL_DYNAMIC_DS_STATE_OBJECT",
"XGL_CMD_BUFFER",
"XGL_FENCE",
"XGL_QUEUE_SEMAPHORE",
Param("XGL_UINT", "startSlot"),
Param("XGL_UINT", "slotCount")]),
- Proto("XGL_RESULT", "CreateViewportState",
+ Proto("XGL_RESULT", "CreateDynamicViewportState",
[Param("XGL_DEVICE", "device"),
- Param("const XGL_VIEWPORT_STATE_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_VIEWPORT_STATE_OBJECT*", "pState")]),
+ Param("const XGL_DYNAMIC_VP_STATE_CREATE_INFO*", "pCreateInfo"),
+ Param("XGL_DYNAMIC_VP_STATE_OBJECT*", "pState")]),
- Proto("XGL_RESULT", "CreateRasterState",
+ Proto("XGL_RESULT", "CreateDynamicRasterState",
[Param("XGL_DEVICE", "device"),
- Param("const XGL_RASTER_STATE_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_RASTER_STATE_OBJECT*", "pState")]),
+ Param("const XGL_DYNAMIC_RS_STATE_CREATE_INFO*", "pCreateInfo"),
+ Param("XGL_DYNAMIC_RS_STATE_OBJECT*", "pState")]),
- Proto("XGL_RESULT", "CreateMsaaState",
+ Proto("XGL_RESULT", "CreateDynamicColorBlendState",
[Param("XGL_DEVICE", "device"),
- Param("const XGL_MSAA_STATE_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_MSAA_STATE_OBJECT*", "pState")]),
+ Param("const XGL_DYNAMIC_CB_STATE_CREATE_INFO*", "pCreateInfo"),
+ Param("XGL_DYNAMIC_CB_STATE_OBJECT*", "pState")]),
- Proto("XGL_RESULT", "CreateColorBlendState",
+ Proto("XGL_RESULT", "CreateDynamicDepthStencilState",
[Param("XGL_DEVICE", "device"),
- Param("const XGL_COLOR_BLEND_STATE_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_COLOR_BLEND_STATE_OBJECT*", "pState")]),
-
- Proto("XGL_RESULT", "CreateDepthStencilState",
- [Param("XGL_DEVICE", "device"),
- Param("const XGL_DEPTH_STENCIL_STATE_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_DEPTH_STENCIL_STATE_OBJECT*", "pState")]),
+ Param("const XGL_DYNAMIC_DS_STATE_CREATE_INFO*", "pCreateInfo"),
+ Param("XGL_DYNAMIC_DS_STATE_OBJECT*", "pState")]),
Proto("XGL_RESULT", "CreateCommandBuffer",
[Param("XGL_DEVICE", "device"),
Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
Param("XGL_PIPELINE_DELTA", "delta")]),
- Proto("XGL_VOID", "CmdBindStateObject",
+ Proto("XGL_VOID", "CmdBindDynamicStateObject",
[Param("XGL_CMD_BUFFER", "cmdBuffer"),
Param("XGL_STATE_BIND_POINT", "stateBindPoint"),
- Param("XGL_STATE_OBJECT", "state")]),
+ Param("XGL_DYNAMIC_STATE_OBJECT", "state")]),
Proto("XGL_VOID", "CmdBindDescriptorSet",
[Param("XGL_CMD_BUFFER", "cmdBuffer"),
projects / platform / upstream / Vulkan-Tools.git / commitdiff