From 29645d043dcb1946879a901391982ee482c75457 Mon Sep 17 00:00:00 2001 From: Tony Barbour Date: Fri, 16 Jan 2015 14:27:35 -0700 Subject: driver:implement changes for Dynamic State --- demos/cube.c | 163 ++++++++++++++++----------- demos/tri.c | 158 ++++++++++++++++----------- include/xgl.h | 296 ++++++++++++++++++++++++++++---------------------- include/xglLayer.h | 11 +- xgl-layer-generate.py | 8 +- xgl.py | 44 ++++---- 6 files changed, 388 insertions(+), 292 deletions(-) diff --git a/demos/cube.c b/demos/cube.c index d42cddc7..f5b27cb3 100644 --- a/demos/cube.c +++ b/demos/cube.c @@ -236,11 +236,10 @@ struct demo { 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; @@ -320,12 +319,11 @@ static void demo_draw_build_cmd(struct demo *demo) 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; @@ -495,8 +493,10 @@ static void demo_prepare_depth(struct demo *demo) 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, @@ -711,6 +711,7 @@ static void demo_prepare_textures(struct demo *demo) .alignment = 0, .flags = 0, .heapCount = 0, + .pHeaps = 0, .memPriority = XGL_MEMORY_PRIORITY_NORMAL, }; XGL_IMAGE_VIEW_CREATE_INFO view = { @@ -747,8 +748,10 @@ static void demo_prepare_textures(struct demo *demo) 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, @@ -837,8 +840,10 @@ void demo_prepare_cube_data_buffer(struct demo *demo) 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); @@ -1046,10 +1051,12 @@ static void demo_prepare_pipeline(struct demo *demo) 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; @@ -1063,15 +1070,36 @@ static void demo_prepare_pipeline(struct demo *demo) 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; @@ -1088,22 +1116,38 @@ static void demo_prepare_pipeline(struct demo *demo) 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); @@ -1115,56 +1159,46 @@ static void demo_prepare_pipeline(struct demo *demo) 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); } @@ -1400,7 +1434,6 @@ static void demo_cleanup(struct demo *demo) xglDestroyObject(demo->viewport); xglDestroyObject(demo->raster); - xglDestroyObject(demo->msaa); xglDestroyObject(demo->color_blend); xglDestroyObject(demo->depth_stencil); diff --git a/demos/tri.c b/demos/tri.c index a4b3656b..82aadc74 100644 --- a/demos/tri.c +++ b/demos/tri.c @@ -68,11 +68,10 @@ struct demo { 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; @@ -144,12 +143,11 @@ static void demo_draw_build_cmd(struct demo *demo) 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); @@ -308,8 +306,10 @@ static void demo_prepare_depth(struct demo *demo) 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, @@ -412,8 +412,10 @@ static void demo_prepare_textures(struct demo *demo) 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, @@ -483,7 +485,7 @@ static void demo_prepare_vertices(struct demo *demo) .alignment = 0, .flags = 0, .heapCount = 0, - .heaps[0] = 0, + .pHeaps = 0, .memPriority = XGL_MEMORY_PRIORITY_NORMAL, }; XGL_MEMORY_REQUIREMENTS mem_reqs; @@ -503,8 +505,9 @@ static void demo_prepare_vertices(struct demo *demo) 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); @@ -645,10 +648,12 @@ static void demo_prepare_pipeline(struct demo *demo) 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; @@ -664,15 +669,38 @@ static void demo_prepare_pipeline(struct demo *demo) 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++) { @@ -686,21 +714,33 @@ static void demo_prepare_pipeline(struct demo *demo) 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); @@ -712,56 +752,47 @@ static void demo_prepare_pipeline(struct demo *demo) 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); } @@ -963,7 +994,6 @@ static void demo_cleanup(struct demo *demo) xglDestroyObject(demo->viewport); xglDestroyObject(demo->raster); - xglDestroyObject(demo->msaa); xglDestroyObject(demo->color_blend); xglDestroyObject(demo->depth_stencil); diff --git a/include/xgl.h b/include/xgl.h index d68047a5..5f90b43f 100644 --- a/include/xgl.h +++ b/include/xgl.h @@ -92,12 +92,11 @@ 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_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) @@ -108,10 +107,6 @@ XGL_DEFINE_SUBCLASS_HANDLE(XGL_RENDER_PASS, 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 @@ -343,12 +338,11 @@ typedef enum _XGL_STATE_BIND_POINT { 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; @@ -469,6 +463,39 @@ typedef enum _XGL_FACE_ORIENTATION 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, @@ -802,17 +829,6 @@ typedef enum _XGL_NUM_FORMAT 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 { @@ -870,10 +886,10 @@ typedef enum _XGL_STRUCTURE_TYPE 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, @@ -882,12 +898,15 @@ typedef enum _XGL_STRUCTURE_TYPE 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, @@ -895,9 +914,6 @@ typedef enum _XGL_STRUCTURE_TYPE 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; @@ -1122,6 +1138,10 @@ typedef struct _XGL_PHYSICAL_GPU_PROPERTIES 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 @@ -1229,7 +1249,7 @@ typedef struct _XGL_MEMORY_ALLOC_INFO 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; @@ -1253,7 +1273,7 @@ typedef struct _XGL_MEMORY_REQUIREMENTS 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 @@ -1498,7 +1518,8 @@ typedef struct _XGL_PIPELINE_SHADER { 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; @@ -1565,10 +1586,9 @@ typedef struct _XGL_PIPELINE_IA_STATE_CREATE_INFO 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 @@ -1580,19 +1600,51 @@ 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; @@ -1601,17 +1653,35 @@ typedef struct _XGL_PIPELINE_CB_STATE_CREATE_INFO 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 { @@ -1649,7 +1719,7 @@ typedef struct _XGL_DESCRIPTOR_SET_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 @@ -1658,25 +1728,27 @@ 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 { @@ -1686,50 +1758,24 @@ 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 { @@ -1949,18 +1995,17 @@ typedef XGL_VOID (XGLAPI *xglAttachImageViewDescriptorsType)(XGL_DESCRIPTOR_SET 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); @@ -2369,30 +2414,25 @@ XGL_VOID XGLAPI xglClearDescriptorSetSlots( // 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 @@ -2423,10 +2463,10 @@ XGL_VOID XGLAPI xglCmdBindPipelineDelta( 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, diff --git a/include/xglLayer.h b/include/xglLayer.h index 8c473baf..3803168e 100644 --- a/include/xglLayer.h +++ b/include/xglLayer.h @@ -90,18 +90,17 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE 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; diff --git a/xgl-layer-generate.py b/xgl-layer-generate.py index e5656dbf..85c4a819 100755 --- a/xgl-layer-generate.py +++ b/xgl-layer-generate.py @@ -558,11 +558,11 @@ class Subcommand(object): "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)" } diff --git a/xgl.py b/xgl.py index ef59f805..996f84ca 100644 --- a/xgl.py +++ b/xgl.py @@ -200,12 +200,11 @@ core = Extension( "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", @@ -542,30 +541,25 @@ core = Extension( 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"), @@ -592,10 +586,10 @@ core = Extension( 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"), -- cgit v1.2.3