XGL_BUFFER_VIEW_ATTACH_INFO attach;
} uniform_data;
- XGL_DESCRIPTOR_SET dset;
-
+ XGL_DESCRIPTOR_SET_LAYOUT desc_layout_vs;
+ XGL_DESCRIPTOR_SET_LAYOUT desc_layout_fs;
+ XGL_DESCRIPTOR_SET_LAYOUT *desc_layout_last;
XGL_PIPELINE pipeline;
XGL_DYNAMIC_VP_STATE_OBJECT viewport;
XGL_CMD_BUFFER cmd;
+ XGL_DESCRIPTOR_REGION desc_region;
+ XGL_DESCRIPTOR_SET desc_set;
+
xcb_window_t window;
xcb_intern_atom_reply_t *atom_wm_delete_window;
xglCmdBindPipeline(demo->cmd, XGL_PIPELINE_BIND_POINT_GRAPHICS,
demo->pipeline);
xglCmdBindDescriptorSet(demo->cmd, XGL_PIPELINE_BIND_POINT_GRAPHICS,
- 0, demo->dset, 0);
+ demo->desc_set, NULL);
xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_VIEWPORT, demo->viewport);
xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_RASTER, demo->raster);
demo->uniform_data.attach.view = demo->uniform_data.view;
}
-static void demo_prepare_descriptor_set(struct demo *demo)
+static void demo_prepare_descriptor_layout(struct demo *demo)
{
- const XGL_DESCRIPTOR_SET_CREATE_INFO descriptor_set = {
- .sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO descriptor_layout_vs = {
+ .sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
.pNext = NULL,
- .slots = DEMO_TEXTURE_COUNT * 2 + 2,
+ .descriptorType = XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+ .count = 1,
+ .stageFlags = XGL_SHADER_STAGE_FLAGS_VERTEX_BIT,
+ .immutableSampler = XGL_NULL_HANDLE,
};
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO descriptor_layout_fs = {
+ .sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+ .pNext = NULL,
+ .descriptorType = XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE,
+ .count = DEMO_TEXTURE_COUNT,
+ .stageFlags = XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT,
+ .immutableSampler = XGL_NULL_HANDLE,
+ };
+ const uint32_t bind_point = 0;
XGL_RESULT err;
- err = xglCreateDescriptorSet(demo->device, &descriptor_set, &demo->dset);
+ err = xglCreateDescriptorSetLayout(demo->device,
+ XGL_SHADER_STAGE_FLAGS_VERTEX_BIT, &bind_point,
+ XGL_NULL_HANDLE, &descriptor_layout_vs,
+ &demo->desc_layout_vs);
assert(!err);
- xglBeginDescriptorSetUpdate(demo->dset);
- xglClearDescriptorSetSlots(demo->dset, 0, DEMO_TEXTURE_COUNT * 2 + 2);
-
-// xglAttachMemoryViewDescriptors(demo->dset, 0, 1, &demo->vertices.view);
-
- xglAttachBufferViewDescriptors(demo->dset, 0, 1, &demo->uniform_data.attach);
-
- XGL_IMAGE_VIEW_ATTACH_INFO image_view;
-
- image_view.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
- image_view.pNext = NULL;
- image_view.view = demo->textures[0].view;
- image_view.layout = XGL_IMAGE_LAYOUT_GENERAL;
-
- xglAttachSamplerDescriptors(demo->dset, 1, 1, &demo->textures[0].sampler);
- xglAttachImageViewDescriptors(demo->dset, 2, 1, &image_view);
+ err = xglCreateDescriptorSetLayout(demo->device,
+ XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT, &bind_point,
+ demo->desc_layout_vs, &descriptor_layout_fs,
+ &demo->desc_layout_fs);
+ assert(!err);
- xglEndDescriptorSetUpdate(demo->dset);
+ demo->desc_layout_last = &demo->desc_layout_fs;
}
static XGL_SHADER demo_prepare_shader(struct demo *demo,
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(&pipeline, 0, sizeof(pipeline));
pipeline.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+ pipeline.lastSetLayout = *demo->desc_layout_last;
memset(&ia, 0, sizeof(ia));
ia.sType = XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO;
ds.stencilTestEnable = XGL_FALSE;
ds.front = ds.back;
- memset(&vs_slots, 0, sizeof(vs_slots));
- vs_slots[0].slotObjectType = XGL_SLOT_SHADER_RESOURCE;
- vs_slots[0].shaderEntityIndex = 0;
-
- memset(&fs_slots, 0, sizeof(fs_slots));
- fs_slots[1].slotObjectType = XGL_SLOT_SHADER_SAMPLER;
- fs_slots[1].shaderEntityIndex = 0;
- fs_slots[2].slotObjectType = XGL_SLOT_SHADER_TEXTURE_RESOURCE;
- fs_slots[2].shaderEntityIndex = 0;
-
memset(&vs, 0, sizeof(vs));
vs.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
vs.shader.stage = XGL_SHADER_STAGE_VERTEX;
vs.shader.shader = demo_prepare_vs(demo);
assert(vs.shader.shader != NULL);
- 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);
- 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;
assert(!err);
}
+static void demo_prepare_descriptor_region(struct demo *demo)
+{
+ const XGL_DESCRIPTOR_TYPE_COUNT type_counts[2] = {
+ [0] = {
+ .type = XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+ .count = 1,
+ },
+ [1] = {
+ .type = XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE,
+ .count = DEMO_TEXTURE_COUNT,
+ },
+ };
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO descriptor_region = {
+ .sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO,
+ .pNext = NULL,
+ .count = 2,
+ .pTypeCount = type_counts,
+ };
+ XGL_RESULT err;
+
+ err = xglCreateDescriptorRegion(demo->device,
+ XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT, 1,
+ &descriptor_region, &demo->desc_region);
+ assert(!err);
+}
+
+static void demo_prepare_descriptor_set(struct demo *demo)
+{
+ const XGL_BUFFER_VIEW_ATTACH_INFO *view_info_vs =
+ &demo->uniform_data.attach;
+ XGL_IMAGE_VIEW_ATTACH_INFO view_info[DEMO_TEXTURE_COUNT];
+ XGL_SAMPLER_IMAGE_VIEW_INFO combined_info[DEMO_TEXTURE_COUNT];
+ XGL_UPDATE_SAMPLER_TEXTURES update_fs;
+ XGL_UPDATE_BUFFERS update_vs;
+ XGL_RESULT err;
+ uint32_t count;
+ XGL_UINT i;
+
+ for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
+ view_info[i].sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
+ view_info[i].pNext = NULL;
+ view_info[i].view = demo->textures[i].view,
+ view_info[i].layout = XGL_IMAGE_LAYOUT_GENERAL;
+
+ combined_info[i].pSampler = demo->textures[i].sampler;
+ combined_info[i].pImageView = &view_info[i];
+ }
+
+ memset(&update_vs, 0, sizeof(update_vs));
+ update_vs.sType = XGL_STRUCTURE_TYPE_UPDATE_BUFFERS;
+ update_vs.pNext = &update_fs;
+ update_vs.descriptorType = XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+ update_vs.count = 1;
+ update_vs.pBufferViews = &view_info_vs;
+
+ memset(&update_fs, 0, sizeof(update_fs));
+ update_fs.sType = XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES;
+ update_fs.index = 1;
+ update_fs.count = DEMO_TEXTURE_COUNT;
+ update_fs.pSamplerImageViews = combined_info;
+
+ err = xglAllocDescriptorSets(demo->desc_region,
+ XGL_DESCRIPTOR_SET_USAGE_STATIC,
+ 1, demo->desc_layout_last,
+ &demo->desc_set, &count);
+ assert(!err && count == 1);
+
+ xglBeginDescriptorRegionUpdate(demo->device,
+ XGL_DESCRIPTOR_UPDATE_MODE_FASTEST);
+
+ xglClearDescriptorSets(demo->desc_region, 1, &demo->desc_set);
+ xglUpdateDescriptors(demo->desc_set, &update_vs);
+
+ xglEndDescriptorRegionUpdate(demo->device, demo->cmd);
+}
+
static void demo_prepare(struct demo *demo)
{
const XGL_CMD_BUFFER_CREATE_INFO cmd = {
demo_prepare_depth(demo);
demo_prepare_textures(demo);
demo_prepare_cube_data_buffer(demo);
- demo_prepare_descriptor_set(demo);
+ demo_prepare_descriptor_layout(demo);
demo_prepare_pipeline(demo);
demo_prepare_dynamic_states(demo);
err = xglCreateCommandBuffer(demo->device, &cmd, &demo->cmd);
assert(!err);
+
+ demo_prepare_descriptor_region(demo);
+ demo_prepare_descriptor_set(demo);
}
static void demo_handle_event(struct demo *demo,
{
XGL_UINT i;
+ xglDestroyObject(demo->desc_set);
+ xglDestroyObject(demo->desc_region);
+
xglDestroyObject(demo->cmd);
xglDestroyObject(demo->viewport);
xglDestroyObject(demo->depth_stencil);
xglDestroyObject(demo->pipeline);
-
- xglDestroyObject(demo->dset);
+ xglDestroyObject(demo->desc_layout_fs);
+ xglDestroyObject(demo->desc_layout_vs);
// xglFreeMemory(demo->vertices.mem);
XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attrs[2];
} vertices;
- XGL_DESCRIPTOR_SET dset;
-
+ XGL_DESCRIPTOR_SET_LAYOUT desc_layout;
XGL_PIPELINE pipeline;
XGL_DYNAMIC_VP_STATE_OBJECT viewport;
XGL_CMD_BUFFER cmd;
+ XGL_DESCRIPTOR_REGION desc_region;
+ XGL_DESCRIPTOR_SET desc_set;
+
xcb_window_t window;
xcb_intern_atom_reply_t *atom_wm_delete_window;
xglCmdBindPipeline(demo->cmd, XGL_PIPELINE_BIND_POINT_GRAPHICS,
demo->pipeline);
xglCmdBindDescriptorSet(demo->cmd, XGL_PIPELINE_BIND_POINT_GRAPHICS,
- 0, demo->dset, 0);
+ demo->desc_set, NULL);
xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_VIEWPORT, demo->viewport);
xglCmdBindDynamicStateObject(demo->cmd, XGL_STATE_BIND_RASTER, demo->raster);
demo->vertices.vi_attrs[1].offsetInBytes = sizeof(float) * 3;
}
-static void demo_prepare_descriptor_set(struct demo *demo)
+static void demo_prepare_descriptor_layout(struct demo *demo)
{
- const XGL_DESCRIPTOR_SET_CREATE_INFO descriptor_set = {
- .sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO descriptor_layout = {
+ .sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
.pNext = NULL,
- .slots = DEMO_TEXTURE_COUNT * 2,
+ .descriptorType = XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE,
+ .count = DEMO_TEXTURE_COUNT,
+ .stageFlags = XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT,
+ .immutableSampler = XGL_NULL_HANDLE,
};
+ const uint32_t bind_point = 0;
XGL_RESULT err;
- XGL_UINT i;
- err = xglCreateDescriptorSet(demo->device, &descriptor_set, &demo->dset);
+ err = xglCreateDescriptorSetLayout(demo->device,
+ XGL_SHADER_STAGE_FLAGS_ALL, &bind_point,
+ XGL_NULL_HANDLE, &descriptor_layout,
+ &demo->desc_layout);
assert(!err);
-
- xglBeginDescriptorSetUpdate(demo->dset);
- xglClearDescriptorSetSlots(demo->dset, 0, DEMO_TEXTURE_COUNT * 2);
-
- for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
- const XGL_IMAGE_VIEW_ATTACH_INFO image_view = {
- .sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO,
- .pNext = NULL,
- .view = demo->textures[i].view,
- .layout = XGL_IMAGE_LAYOUT_GENERAL,
- };
-
- xglAttachSamplerDescriptors(demo->dset, 2 * i, 1,
- &demo->textures[i].sampler);
- xglAttachImageViewDescriptors(demo->dset, 2 * i + 1, 1,
- &image_view);
- }
-
- xglEndDescriptorSetUpdate(demo->dset);
}
static XGL_SHADER demo_prepare_shader(struct demo *demo,
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(&pipeline, 0, sizeof(pipeline));
pipeline.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+ pipeline.lastSetLayout = demo->desc_layout;
vi = demo->vertices.vi;
ds.stencilTestEnable = XGL_FALSE;
ds.front = ds.back;
- memset(&fs_slots, 0, sizeof(fs_slots));
- for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
- fs_slots[2 * i].slotObjectType = XGL_SLOT_SHADER_SAMPLER;
- fs_slots[2 * i].shaderEntityIndex = i;
- fs_slots[2 * i + 1].slotObjectType = XGL_SLOT_SHADER_TEXTURE_RESOURCE;
- fs_slots[2 * i + 1].shaderEntityIndex = i;
- }
-
memset(&vs, 0, sizeof(vs));
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);
- 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;
assert(!err);
}
+static void demo_prepare_descriptor_region(struct demo *demo)
+{
+ const XGL_DESCRIPTOR_TYPE_COUNT type_count = {
+ .type = XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE,
+ .count = DEMO_TEXTURE_COUNT,
+ };
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO descriptor_region = {
+ .sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO,
+ .pNext = NULL,
+ .count = 1,
+ .pTypeCount = &type_count,
+ };
+ XGL_RESULT err;
+
+ err = xglCreateDescriptorRegion(demo->device,
+ XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT, 1,
+ &descriptor_region, &demo->desc_region);
+ assert(!err);
+}
+
+static void demo_prepare_descriptor_set(struct demo *demo)
+{
+ XGL_IMAGE_VIEW_ATTACH_INFO view_info[DEMO_TEXTURE_COUNT];
+ XGL_SAMPLER_IMAGE_VIEW_INFO combined_info[DEMO_TEXTURE_COUNT];
+ XGL_UPDATE_SAMPLER_TEXTURES update;
+ XGL_RESULT err;
+ uint32_t count;
+ XGL_UINT i;
+
+ for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
+ view_info[i].sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
+ view_info[i].pNext = NULL;
+ view_info[i].view = demo->textures[i].view,
+ view_info[i].layout = XGL_IMAGE_LAYOUT_GENERAL;
+
+ combined_info[i].pSampler = demo->textures[i].sampler;
+ combined_info[i].pImageView = &view_info[i];
+ }
+
+ memset(&update, 0, sizeof(update));
+ update.sType = XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES;
+ update.count = DEMO_TEXTURE_COUNT;
+ update.pSamplerImageViews = combined_info;
+
+ err = xglAllocDescriptorSets(demo->desc_region,
+ XGL_DESCRIPTOR_SET_USAGE_STATIC,
+ 1, &demo->desc_layout,
+ &demo->desc_set, &count);
+ assert(!err && count == 1);
+
+ xglBeginDescriptorRegionUpdate(demo->device,
+ XGL_DESCRIPTOR_UPDATE_MODE_FASTEST);
+
+ xglClearDescriptorSets(demo->desc_region, 1, &demo->desc_set);
+ xglUpdateDescriptors(demo->desc_set, &update);
+
+ xglEndDescriptorRegionUpdate(demo->device, demo->cmd);
+}
+
static void demo_prepare(struct demo *demo)
{
const XGL_CMD_BUFFER_CREATE_INFO cmd = {
demo_prepare_depth(demo);
demo_prepare_textures(demo);
demo_prepare_vertices(demo);
- demo_prepare_descriptor_set(demo);
-
+ demo_prepare_descriptor_layout(demo);
demo_prepare_pipeline(demo);
demo_prepare_dynamic_states(demo);
err = xglCreateCommandBuffer(demo->device, &cmd, &demo->cmd);
assert(!err);
+
+ demo_prepare_descriptor_region(demo);
+ demo_prepare_descriptor_set(demo);
}
static void demo_handle_event(struct demo *demo,
{
XGL_UINT i;
+ xglDestroyObject(demo->desc_set);
+ xglDestroyObject(demo->desc_region);
+
xglDestroyObject(demo->cmd);
xglDestroyObject(demo->viewport);
xglDestroyObject(demo->depth_stencil);
xglDestroyObject(demo->pipeline);
-
- xglDestroyObject(demo->dset);
+ xglDestroyObject(demo->desc_layout);
xglBindObjectMemory(demo->vertices.buf, XGL_NULL_HANDLE, 0);
xglDestroyObject(demo->vertices.buf);
cmd_mi.c
cmd_prepare.c
cmd_pipeline.c
+ desc.c
dev.c
- dset.c
intel.c
intel_gpa.c
event.c
if (cmd->bind.shader_cache.entries)
icd_free(cmd->bind.shader_cache.entries);
+ if (cmd->bind.dset.graphics_dynamic_offsets)
+ icd_free(cmd->bind.dset.graphics_dynamic_offsets);
+ if (cmd->bind.dset.compute_dynamic_offsets)
+ icd_free(cmd->bind.dset.compute_dynamic_offsets);
+
memset(&cmd->bind, 0, sizeof(cmd->bind));
cmd->reloc_used = 0;
struct intel_msaa_state;
struct intel_blend_state;
struct intel_ds_state;
-struct intel_dset;
+struct intel_desc_set;
struct intel_cmd_item;
struct intel_cmd_reloc;
} state;
struct {
- const struct intel_dset *graphics;
- XGL_UINT graphics_offset;
- const struct intel_dset *compute;
- XGL_UINT compute_offset;
+ const struct intel_desc_set *graphics;
+ uint32_t *graphics_dynamic_offsets;
+ size_t graphics_dynamic_offset_size;
+ const struct intel_desc_set *compute;
+ uint32_t *compute_dynamic_offsets;
+ size_t compute_dynamic_offset_size;
} dset;
struct {
- struct intel_buf_view *graphics;
- struct intel_buf_view *compute;
- } dyn_view;
-
- struct {
const struct intel_buf *buf[INTEL_MAX_VERTEX_BINDING_COUNT];
XGL_GPU_SIZE offset[INTEL_MAX_VERTEX_BINDING_COUNT];
} vertex;
*/
#include "genhw/genhw.h"
-#include "dset.h"
#include "buf.h"
+#include "desc.h"
#include "img.h"
#include "mem.h"
#include "pipeline.h"
&rmap->slots[surface_count + i];
const struct intel_sampler *sampler;
- switch (slot->path_len) {
- case 0:
- sampler = NULL;
+ switch (slot->type) {
+ case INTEL_PIPELINE_RMAP_SAMPLER:
+ intel_desc_pool_read_sampler(cmd->dev->desc_pool,
+ &slot->u.sampler, &sampler);
break;
- case INTEL_PIPELINE_RMAP_SLOT_RT:
- case INTEL_PIPELINE_RMAP_SLOT_DYN:
- assert(!"unexpected rmap slot type");
+ case INTEL_PIPELINE_RMAP_UNUSED:
sampler = NULL;
break;
- case 1:
- {
- const struct intel_dset *dset = cmd->bind.dset.graphics;
- const XGL_UINT slot_offset = cmd->bind.dset.graphics_offset;
- const struct intel_dset_slot *dset_slot =
- &dset->slots[slot_offset + slot->u.index];
-
- switch (dset_slot->type) {
- case INTEL_DSET_SLOT_SAMPLER:
- sampler = dset_slot->u.sampler;
- break;
- default:
- assert(!"unexpected dset slot type");
- sampler = NULL;
- break;
- }
- }
- break;
default:
- assert(!"nested descriptor set unsupported");
+ assert(!"unexpected rmap type");
sampler = NULL;
break;
}
for (i = 0; i < surface_count; i++) {
const struct intel_pipeline_rmap_slot *slot = &rmap->slots[i];
+ struct intel_null_view null_view;
+ bool need_null_view = false;
- switch (slot->path_len) {
- case 0:
- offset = 0;
- break;
- case INTEL_PIPELINE_RMAP_SLOT_RT:
+ switch (slot->type) {
+ case INTEL_PIPELINE_RMAP_RT:
{
const struct intel_rt_view *view =
- (slot->u.index < cmd->bind.render_pass->fb->rt_count) ?
- cmd->bind.render_pass->fb->rt[slot->u.index] : NULL;
+ (slot->u.rt < cmd->bind.render_pass->fb->rt_count) ?
+ cmd->bind.render_pass->fb->rt[slot->u.rt] : NULL;
if (view) {
offset = cmd_surface_write(cmd, INTEL_CMD_ITEM_SURFACE,
cmd_surface_reloc(cmd, offset, 1, view->img->obj.mem->bo,
view->cmd[1], INTEL_RELOC_WRITE);
} else {
- struct intel_null_view null_view;
- intel_null_view_init(&null_view, cmd->dev);
-
- offset = cmd_surface_write(cmd, INTEL_CMD_ITEM_SURFACE,
- GEN6_ALIGNMENT_SURFACE_STATE,
- null_view.cmd_len, null_view.cmd);
+ need_null_view = true;
}
}
break;
- case INTEL_PIPELINE_RMAP_SLOT_DYN:
+ case INTEL_PIPELINE_RMAP_SURFACE:
{
- const struct intel_buf_view *view =
- cmd->bind.dyn_view.graphics;
-
- offset = cmd_surface_write(cmd, INTEL_CMD_ITEM_SURFACE,
- GEN6_ALIGNMENT_SURFACE_STATE,
- view->cmd_len, view->cmd);
+ const int32_t dyn_idx = slot->u.surface.dynamic_offset_index;
+ const struct intel_mem *mem;
+ bool read_only;
+ const uint32_t *cmd_data;
+ uint32_t cmd_len;
+
+ assert(dyn_idx < 0 || dyn_idx <
+ cmd->bind.dset.graphics->layout->dynamic_desc_count);
+
+ intel_desc_pool_read_surface(cmd->dev->desc_pool,
+ &slot->u.surface.offset, stage, &mem,
+ &read_only, &cmd_data, &cmd_len);
+ if (mem) {
+ const uint32_t dynamic_offset = (dyn_idx >= 0) ?
+ cmd->bind.dset.graphics_dynamic_offsets[dyn_idx] : 0;
+ const uint32_t reloc_flags =
+ (read_only) ? 0 : INTEL_RELOC_WRITE;
- cmd_reserve_reloc(cmd, 1);
- cmd_surface_reloc(cmd, offset, 1, view->buf->obj.mem->bo,
- view->cmd[1], INTEL_RELOC_WRITE);
- }
- break;
- case 1:
- {
- const struct intel_dset *dset = cmd->bind.dset.graphics;
- const XGL_UINT slot_offset = cmd->bind.dset.graphics_offset;
- const struct intel_dset_slot *dset_slot =
- &dset->slots[slot_offset + slot->u.index];
- const uint32_t reloc_flags =
- (dset_slot->read_only) ? 0 : INTEL_RELOC_WRITE;
-
- switch (dset_slot->type) {
- case INTEL_DSET_SLOT_IMG_VIEW:
offset = cmd_surface_write(cmd, INTEL_CMD_ITEM_SURFACE,
GEN6_ALIGNMENT_SURFACE_STATE,
- dset_slot->u.img_view->cmd_len,
- dset_slot->u.img_view->cmd);
+ cmd_len, cmd_data);
cmd_reserve_reloc(cmd, 1);
- cmd_surface_reloc(cmd, offset, 1,
- dset_slot->u.img_view->img->obj.mem->bo,
- dset_slot->u.img_view->cmd[1], reloc_flags);
- break;
- case INTEL_DSET_SLOT_BUF_VIEW:
- {
- const uint32_t *cmd_data =
- (stage != XGL_SHADER_STAGE_FRAGMENT) ?
- dset_slot->u.buf_view->cmd :
- dset_slot->u.buf_view->fs_cmd;
-
- offset = cmd_surface_write(cmd, INTEL_CMD_ITEM_SURFACE,
- GEN6_ALIGNMENT_SURFACE_STATE,
- dset_slot->u.buf_view->cmd_len,
- cmd_data);
-
- cmd_reserve_reloc(cmd, 1);
- cmd_surface_reloc(cmd, offset, 1,
- dset_slot->u.buf_view->buf->obj.mem->bo,
- cmd_data[1], reloc_flags);
- }
- break;
- case INTEL_DSET_SLOT_SAMPLER:
- assert(0 == cmd->bind.dset.graphics_offset);
-
- offset = cmd_surface_write(cmd, INTEL_CMD_ITEM_SURFACE,
- GEN6_ALIGNMENT_SURFACE_STATE,
- 16, dset_slot->u.sampler->cmd);
- break;
- default:
- assert(!"unexpected dset slot type");
- break;
+ cmd_surface_reloc(cmd, offset, 1, mem->bo,
+ cmd_data[1] + dynamic_offset, reloc_flags);
+ } else {
+ need_null_view = true;
}
}
break;
+ case INTEL_PIPELINE_RMAP_UNUSED:
+ need_null_view = true;
+ break;
default:
- assert(!"nested descriptor set unsupported");
+ assert(!"unexpected rmap type");
+ need_null_view = true;
break;
}
+ if (need_null_view) {
+ intel_null_view_init(&null_view, cmd->dev);
+ offset = cmd_surface_write(cmd, INTEL_CMD_ITEM_SURFACE,
+ GEN6_ALIGNMENT_SURFACE_STATE,
+ null_view.cmd_len, null_view.cmd);
+ }
+
binding_table[i] = offset;
}
}
static void cmd_bind_graphics_dset(struct intel_cmd *cmd,
- const struct intel_dset *dset,
- XGL_UINT slot_offset)
+ const struct intel_desc_set *dset,
+ const uint32_t *dynamic_offsets)
{
+ const uint32_t size = sizeof(*dynamic_offsets) *
+ dset->layout->dynamic_desc_count;
+
+ if (size > cmd->bind.dset.graphics_dynamic_offset_size) {
+ if (cmd->bind.dset.graphics_dynamic_offsets)
+ icd_free(cmd->bind.dset.graphics_dynamic_offsets);
+
+ cmd->bind.dset.graphics_dynamic_offsets = icd_alloc(size,
+ 4, XGL_SYSTEM_ALLOC_INTERNAL);
+ if (!cmd->bind.dset.graphics_dynamic_offsets) {
+ cmd->result = XGL_ERROR_OUT_OF_MEMORY;
+ return;
+ }
+
+ cmd->bind.dset.graphics_dynamic_offset_size = size;
+ }
+
cmd->bind.dset.graphics = dset;
- cmd->bind.dset.graphics_offset = slot_offset;
+ memcpy(cmd->bind.dset.graphics_dynamic_offsets, dynamic_offsets, size);
}
static void cmd_bind_compute_dset(struct intel_cmd *cmd,
- const struct intel_dset *dset,
- XGL_UINT slot_offset)
+ const struct intel_desc_set *dset,
+ const uint32_t *dynamic_offsets)
{
- cmd->bind.dset.compute = dset;
- cmd->bind.dset.compute_offset = slot_offset;
-}
+ const uint32_t size = sizeof(*dynamic_offsets) *
+ dset->layout->dynamic_desc_count;
-static void cmd_bind_graphics_dyn_view(struct intel_cmd *cmd,
- const XGL_BUFFER_VIEW_ATTACH_INFO *info)
-{
- cmd->bind.dyn_view.graphics = intel_buf_view(info->view);
-}
+ if (size > cmd->bind.dset.compute_dynamic_offset_size) {
+ if (cmd->bind.dset.compute_dynamic_offsets)
+ icd_free(cmd->bind.dset.compute_dynamic_offsets);
-static void cmd_bind_compute_dyn_view(struct intel_cmd *cmd,
- const XGL_BUFFER_VIEW_ATTACH_INFO *info)
-{
- cmd->bind.dyn_view.compute = intel_buf_view(info->view);
+ cmd->bind.dset.compute_dynamic_offsets = icd_alloc(size,
+ 4, XGL_SYSTEM_ALLOC_INTERNAL);
+ if (!cmd->bind.dset.compute_dynamic_offsets) {
+ cmd->result = XGL_ERROR_OUT_OF_MEMORY;
+ return;
+ }
+
+ cmd->bind.dset.compute_dynamic_offset_size = size;
+ }
+
+ cmd->bind.dset.compute = dset;
+ memcpy(cmd->bind.dset.compute_dynamic_offsets, dynamic_offsets, size);
}
static void cmd_bind_vertex_data(struct intel_cmd *cmd,
ICD_EXPORT XGL_VOID XGLAPI xglCmdBindDescriptorSet(
XGL_CMD_BUFFER cmdBuffer,
XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_UINT index,
XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT slotOffset)
-{
- struct intel_cmd *cmd = intel_cmd(cmdBuffer);
- struct intel_dset *dset = intel_dset(descriptorSet);
-
- assert(!index);
-
- switch (pipelineBindPoint) {
- case XGL_PIPELINE_BIND_POINT_COMPUTE:
- cmd_bind_compute_dset(cmd, dset, slotOffset);
- break;
- case XGL_PIPELINE_BIND_POINT_GRAPHICS:
- cmd_bind_graphics_dset(cmd, dset, slotOffset);
- break;
- default:
- cmd->result = XGL_ERROR_INVALID_VALUE;
- break;
- }
-}
-
-ICD_EXPORT XGL_VOID XGLAPI xglCmdBindDynamicBufferView(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferView)
+ const XGL_UINT* pUserData)
{
struct intel_cmd *cmd = intel_cmd(cmdBuffer);
+ struct intel_desc_set *dset = intel_desc_set(descriptorSet);
switch (pipelineBindPoint) {
case XGL_PIPELINE_BIND_POINT_COMPUTE:
- cmd_bind_compute_dyn_view(cmd, pBufferView);
+ cmd_bind_compute_dset(cmd, dset, pUserData);
break;
case XGL_PIPELINE_BIND_POINT_GRAPHICS:
- cmd_bind_graphics_dyn_view(cmd, pBufferView);
+ cmd_bind_graphics_dset(cmd, dset, pUserData);
break;
default:
cmd->result = XGL_ERROR_INVALID_VALUE;
* LunarG
*/
+extern "C" {
+#include "desc.h"
#include "gpu.h"
#include "shader.h"
#include "pipeline.h"
+}
+
#include "compiler/shader/compiler_interface.h"
#include "compiler/pipeline/pipeline_compiler_interface.h"
#include "compiler/pipeline/brw_context.h"
#include "compiler/pipeline/brw_device_info.h"
#include "compiler/pipeline/brw_wm.h"
+struct brw_binding_table {
+ uint32_t count;
+
+ uint32_t rt_start;
+
+ uint32_t texture_start;
+ uint32_t texture_used;
+
+ uint32_t ubo_start;
+};
static void initialize_brw_context(struct brw_context *brw,
const struct intel_gpu *gpu)
fflush(fp);
}
-static struct intel_pipeline_rmap_slot *rmap_get_slot(struct intel_pipeline_rmap *rmap,
- XGL_DESCRIPTOR_SET_SLOT_TYPE type,
- XGL_UINT index)
-{
- // The ordering of below offsets is important. Textures need to come before
- // buffers with the current compiler conventions.
- const XGL_UINT texture_resource_offset = rmap->rt_count;
- const XGL_UINT resource_offset = texture_resource_offset + rmap->texture_resource_count;
- const XGL_UINT uav_offset = resource_offset + rmap->resource_count;
- const XGL_UINT sampler_offset = uav_offset + rmap->uav_count;
- struct intel_pipeline_rmap_slot *slot;
-
- switch (type) {
- case XGL_SLOT_UNUSED:
- slot = NULL;
- break;
- case XGL_SLOT_SHADER_TEXTURE_RESOURCE:
- slot = &rmap->slots[texture_resource_offset + index];
- break;
- case XGL_SLOT_SHADER_RESOURCE:
- slot = &rmap->slots[resource_offset + index];
- break;
- case XGL_SLOT_SHADER_UAV:
- slot = &rmap->slots[uav_offset + index];
- break;
- case XGL_SLOT_SHADER_SAMPLER:
- slot = &rmap->slots[sampler_offset + index];
- break;
- default:
- assert(!"unknown rmap slot type");
- slot = NULL;
- break;
- }
-
- return slot;
-}
-
-static bool rmap_init_slots_with_path(struct intel_pipeline_rmap *rmap,
- const XGL_DESCRIPTOR_SET_MAPPING *mapping,
- XGL_UINT *nest_path,
- XGL_UINT nest_level)
-{
- XGL_UINT i;
-
- for (i = 0; i < mapping->descriptorCount; i++) {
- const XGL_DESCRIPTOR_SLOT_INFO *info = &mapping->pDescriptorInfo[i];
- struct intel_pipeline_rmap_slot *slot;
-
- if (info->slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET) {
- nest_path[nest_level] = i;
- if (!rmap_init_slots_with_path(rmap, info->pNextLevelSet,
- nest_path, nest_level + 1))
- return false;
-
- continue;
- }
-
- slot = rmap_get_slot(rmap, info->slotObjectType,
- info->shaderEntityIndex);
- if (!slot || slot->path_len)
- continue;
-
- slot->path_len = nest_level + 1;
-
- if (nest_level) {
- slot->u.path = (XGL_UINT *) icd_alloc(sizeof(slot->u.path[0]) *
- slot->path_len, 0, XGL_SYSTEM_ALLOC_INTERNAL);
- if (!slot->u.path) {
- slot->path_len = 0;
- return false;
- }
-
- memcpy(slot->u.path, nest_path,
- sizeof(slot->u.path[0]) * nest_level);
- slot->u.path[nest_level] = i;
- } else {
- slot->u.index = i;
- }
- }
-
- return true;
-}
-
-static bool rmap_init_slots(struct intel_pipeline_rmap *rmap,
- const XGL_DESCRIPTOR_SET_MAPPING *mapping,
- XGL_UINT depth)
-{
- XGL_UINT *nest_path;
- bool ok;
-
- if (depth) {
- nest_path = (XGL_UINT *) icd_alloc(sizeof(nest_path[0]) * depth,
- 0, XGL_SYSTEM_ALLOC_INTERNAL_TEMP);
- if (!nest_path)
- return false;
- } else {
- nest_path = NULL;
- }
-
- ok = rmap_init_slots_with_path(rmap, mapping, nest_path, 0);
-
- if (nest_path)
- icd_free(nest_path);
-
- return ok;
-}
-
-static void rmap_update_count(struct intel_pipeline_rmap *rmap,
- XGL_DESCRIPTOR_SET_SLOT_TYPE type,
- XGL_UINT index, XGL_UINT rt_count, XGL_UINT ubo_start)
-{
- rmap->rt_count = rt_count;
-
- switch (type) {
- case XGL_SLOT_UNUSED:
- break;
- case XGL_SLOT_SHADER_TEXTURE_RESOURCE:
- if (rmap->texture_resource_count < index + 1)
- if (index < ubo_start - rt_count)
- rmap->texture_resource_count = index + 1;
- break;
- case XGL_SLOT_SHADER_RESOURCE:
- if (rmap->resource_count < index + 1)
- rmap->resource_count = index + 1;
- break;
- case XGL_SLOT_SHADER_UAV:
- if (rmap->uav_count < index + 1)
- rmap->uav_count = index + 1;
- break;
- case XGL_SLOT_SHADER_SAMPLER:
- if (rmap->sampler_count < index + 1)
- rmap->sampler_count = index + 1;
- break;
- default:
- assert(!"unknown rmap slot type");
- break;
- }
-}
-
-static XGL_UINT rmap_init_counts(struct intel_pipeline_rmap *rmap,
- const XGL_DESCRIPTOR_SET_MAPPING *mapping,
- XGL_UINT rt_count, XGL_UINT ubo_start)
-{
- XGL_UINT depth = 0;
- XGL_UINT i;
-
- for (i = 0; i < mapping->descriptorCount; i++) {
- const XGL_DESCRIPTOR_SLOT_INFO *info = &mapping->pDescriptorInfo[i];
-
- if (info->slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET) {
- const XGL_UINT d = rmap_init_counts(rmap,
- info->pNextLevelSet, rt_count, ubo_start);
- if (depth < d + 1)
- depth = d + 1;
-
- continue;
- }
-
- rmap_update_count(rmap, info->slotObjectType,
- info->shaderEntityIndex, rt_count, ubo_start);
- }
-
- return depth;
-}
-
static void rmap_destroy(struct intel_pipeline_rmap *rmap)
{
- XGL_UINT i;
-
- for (i = 0; i < rmap->slot_count; i++) {
- struct intel_pipeline_rmap_slot *slot = &rmap->slots[i];
-
- switch (slot->path_len) {
- case 0:
- case 1:
- case INTEL_PIPELINE_RMAP_SLOT_RT:
- case INTEL_PIPELINE_RMAP_SLOT_DYN:
- break;
- default:
- icd_free(slot->u.path);
- break;
- }
- }
-
icd_free(rmap->slots);
icd_free(rmap);
}
static struct intel_pipeline_rmap *rmap_create(const struct intel_gpu *gpu,
- const XGL_DESCRIPTOR_SET_MAPPING *mapping,
- const XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO *dyn,
- XGL_UINT rt_count, XGL_UINT ubo_start)
+ XGL_PIPELINE_SHADER_STAGE stage,
+ const struct intel_desc_layout *layout,
+ const struct brw_binding_table *bt)
{
struct intel_pipeline_rmap *rmap;
- struct intel_pipeline_rmap_slot *slot;
- XGL_UINT depth, rt;
+ struct intel_desc_layout_iter iter;
+ uint32_t surface_count, i;
rmap = (struct intel_pipeline_rmap *)
icd_alloc(sizeof(*rmap), 0, XGL_SYSTEM_ALLOC_INTERNAL);
memset(rmap, 0, sizeof(*rmap));
- depth = rmap_init_counts(rmap, mapping, rt_count, ubo_start);
-
- /* add RTs and the dynamic buffer view */
- rmap_update_count(rmap, dyn->slotObjectType, dyn->shaderEntityIndex, rt_count, ubo_start);
-
- rmap->slot_count = rmap->rt_count + rmap->texture_resource_count + rmap->resource_count +
- rmap->uav_count + rmap->sampler_count;
+ /* Fix the compiler and fix these! No point in understanding them. */
+ rmap->rt_count = bt->texture_start;
+ rmap->texture_resource_count = bt->ubo_start - bt->texture_start;
+ rmap->uav_count = bt->count - bt->ubo_start;
+ rmap->sampler_count = rmap->texture_resource_count;
+ surface_count = rmap->rt_count + rmap->texture_resource_count +
+ rmap->uav_count;
+ rmap->slot_count = surface_count + rmap->sampler_count;
rmap->slots = (struct intel_pipeline_rmap_slot *)
icd_alloc(sizeof(rmap->slots[0]) * rmap->slot_count,
memset(rmap->slots, 0, sizeof(rmap->slots[0]) * rmap->slot_count);
- if (!rmap_init_slots(rmap, mapping, depth)) {
- rmap_destroy(rmap);
- return NULL;
+ for (i = 0; i < bt->rt_start; i++)
+ rmap->slots[i].type = INTEL_PIPELINE_RMAP_UNUSED;
+
+ for (i = bt->rt_start; i < bt->texture_start; i++) {
+ rmap->slots[i].type = INTEL_PIPELINE_RMAP_RT;
+ rmap->slots[i].u.rt = i - bt->rt_start;
}
- /* add RTs and the dynamic buffer view */
- slot = rmap_get_slot(rmap, dyn->slotObjectType, dyn->shaderEntityIndex);
- if (slot) {
- slot->path_len = INTEL_PIPELINE_RMAP_SLOT_DYN;
- slot->u.index = 0;
+ intel_desc_layout_find_bind_point(layout, stage, 0, 0, &iter);
+ for (i = bt->texture_start; i < bt->ubo_start; i++) {
+ if (bt->texture_used & (1 << (i - bt->texture_start))) {
+ rmap->slots[i].type = INTEL_PIPELINE_RMAP_SURFACE;
+ rmap->slots[i].u.surface.offset = iter.offset_begin;
+ rmap->slots[i].u.surface.dynamic_offset_index = -1;
+
+ rmap->slots[bt->count + i - bt->texture_start].type =
+ INTEL_PIPELINE_RMAP_SAMPLER;
+ rmap->slots[bt->count + i - bt->texture_start].u.sampler =
+ iter.offset_begin;
+ } else {
+ rmap->slots[i].type = INTEL_PIPELINE_RMAP_UNUSED;
+
+ rmap->slots[bt->count + i - bt->texture_start].type =
+ INTEL_PIPELINE_RMAP_UNUSED;;
+ }
+
+ intel_desc_layout_advance_iter(layout, &iter);
}
- for (rt = 0; rt < rmap->rt_count; rt++) {
- slot = &rmap->slots[rt];
- slot->path_len = INTEL_PIPELINE_RMAP_SLOT_RT;
- slot->u.index = rt;
+
+ intel_desc_layout_find_bind_point(layout, stage, 0, 0, &iter);
+ for (i = bt->ubo_start; i < bt->count; i++) {
+ rmap->slots[i].type = INTEL_PIPELINE_RMAP_SURFACE;
+ rmap->slots[i].u.surface.offset = iter.offset_begin;
+ rmap->slots[i].u.surface.dynamic_offset_index = -1;
+
+ intel_desc_layout_advance_iter(layout, &iter);
}
return rmap;
// invoke backend compiler to generate ISA and supporting data structures
XGL_RESULT intel_pipeline_shader_compile(struct intel_pipeline_shader *pipe_shader,
const struct intel_gpu *gpu,
+ const struct intel_desc_layout *layout,
const XGL_PIPELINE_SHADER *info)
{
const struct intel_ir *ir = intel_shader(info->shader)->ir;
/* XXX how about constness? */
struct gl_shader_program *sh_prog = (struct gl_shader_program *) ir;
XGL_RESULT status = XGL_SUCCESS;
+ struct brw_binding_table bt;
struct brw_context *brw = intel_create_brw_context(gpu);
+ memset(&bt, 0, sizeof(bt));
+
// LunarG : TODO - should this have been set for us somewhere?
sh_prog->Type = sh_prog->Shaders[0]->Stage;
pipe_shader->surface_count = data->base.base.binding_table.size_bytes / 4;
pipe_shader->ubo_start = data->base.base.binding_table.ubo_start;
+ bt.count = data->base.base.binding_table.size_bytes / 4;
+ bt.texture_start = data->base.base.binding_table.texture_start;
+ bt.texture_used = sh_prog->_LinkedShaders[MESA_SHADER_VERTEX]->Program->SamplersUsed;
+ bt.ubo_start = data->base.base.binding_table.ubo_start;
+
pipe_shader->per_thread_scratch_size = data->base.total_scratch;
if (unlikely(INTEL_DEBUG & DEBUG_VS)) {
}
}
+ bt.count = data->base.binding_table.size_bytes / 4;
+ bt.rt_start = data->binding_table.render_target_start;
+ bt.texture_start = data->base.binding_table.texture_start;
+ bt.texture_used = sh_prog->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program->SamplersUsed;
+ bt.ubo_start = data->base.binding_table.ubo_start;
+
// Ensure this is 1:1, or create a converter
pipe_shader->barycentric_interps = data->barycentric_interp_modes;
}
if (status == XGL_SUCCESS) {
- XGL_UINT rt_count = 0;
-
- if (info->stage == XGL_SHADER_STAGE_FRAGMENT) {
- const struct gl_program *prog =
- sh_prog->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program;
-
- rt_count = _mesa_bitcount_64(prog->OutputsWritten &
- ~(BITFIELD64_BIT(FRAG_RESULT_DEPTH) |
- BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK)));
- }
-
- XGL_DESCRIPTOR_SET_MAPPING null_map;
- XGL_DESCRIPTOR_SET_MAPPING *pMapping = info->pDescriptorSetMapping;
- null_map.descriptorCount = 0;
-
- if (! info->descriptorSetMappingCount) {
- pMapping = &null_map;
- }
-
- pipe_shader->rmap = rmap_create(gpu,
- pMapping,
- &info->dynamicBufferViewMapping,
- rt_count, pipe_shader->ubo_start);
-
- if (pipe_shader->rmap) {
- // Ensure that all textures in descriptor set were consumed. This
- // is temporary until we move resource map building to compiler.
- assert(pipe_shader->ubo_start == rt_count +
- pipe_shader->rmap->texture_resource_count);
- } else {
+ pipe_shader->rmap = rmap_create(gpu, info->stage, layout, &bt);
+ if (!pipe_shader->rmap) {
intel_pipeline_shader_cleanup(pipe_shader);
status = XGL_ERROR_OUT_OF_MEMORY;
}
#include "dev.h"
struct brw_context;
+struct intel_desc_layout;
struct intel_gpu;
struct intel_ir;
struct intel_pipeline_shader;
XGL_RESULT intel_pipeline_shader_compile(struct intel_pipeline_shader *ips,
const struct intel_gpu *gpu,
+ const struct intel_desc_layout *layout,
const XGL_PIPELINE_SHADER *info);
void intel_pipeline_shader_cleanup(struct intel_pipeline_shader *sh);
--- /dev/null
+/*
+ * XGL
+ *
+ * Copyright (C) 2015 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ * Chia-I Wu <olv@lunarg.com>
+ */
+
+#include "buf.h"
+#include "cmd.h"
+#include "dev.h"
+#include "gpu.h"
+#include "img.h"
+#include "sampler.h"
+#include "view.h"
+#include "desc.h"
+
+enum intel_desc_surface_type {
+ INTEL_DESC_SURFACE_UNUSED,
+ INTEL_DESC_SURFACE_BUF,
+ INTEL_DESC_SURFACE_IMG,
+};
+
+struct intel_desc_surface {
+ const struct intel_mem *mem;
+ bool read_only;
+
+ enum intel_desc_surface_type type;
+ union {
+ const void *unused;
+ const struct intel_buf_view *buf;
+ const struct intel_img_view *img;
+ } u;
+};
+
+struct intel_desc_sampler {
+ const struct intel_sampler *sampler;
+};
+
+static bool desc_pool_init_desc_sizes(struct intel_desc_pool *pool,
+ const struct intel_gpu *gpu)
+{
+ pool->surface_desc_size = sizeof(struct intel_desc_surface);
+ pool->sampler_desc_size = sizeof(struct intel_desc_sampler);
+
+ return true;
+}
+
+XGL_RESULT intel_desc_pool_create(struct intel_dev *dev,
+ struct intel_desc_pool **pool_ret)
+{
+ const uint32_t surface_count = 16384;
+ const uint32_t sampler_count = 16384;
+ struct intel_desc_pool *pool;
+
+ pool = icd_alloc(sizeof(*pool), 0, XGL_SYSTEM_ALLOC_INTERNAL);
+ if (!pool)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ memset(pool, 0, sizeof(*pool));
+
+ if (!desc_pool_init_desc_sizes(pool, dev->gpu)) {
+ icd_free(pool);
+ return XGL_ERROR_UNKNOWN;
+ }
+
+ intel_desc_offset_set(&pool->size,
+ pool->surface_desc_size * surface_count,
+ pool->sampler_desc_size * sampler_count);
+
+ pool->surfaces = icd_alloc(pool->size.surface,
+ 64, XGL_SYSTEM_ALLOC_INTERNAL);
+ if (!pool->surfaces) {
+ icd_free(pool);
+ return XGL_ERROR_OUT_OF_MEMORY;
+ }
+
+ pool->samplers = icd_alloc(pool->size.sampler,
+ 64, XGL_SYSTEM_ALLOC_INTERNAL);
+ if (!pool->samplers) {
+ icd_free(pool->surfaces);
+ icd_free(pool);
+ return XGL_ERROR_OUT_OF_MEMORY;
+ }
+
+ *pool_ret = pool;
+
+ return XGL_SUCCESS;
+}
+
+void intel_desc_pool_destroy(struct intel_desc_pool *pool)
+{
+ icd_free(pool->samplers);
+ icd_free(pool->surfaces);
+ icd_free(pool);
+}
+
+/**
+ * Get the size of a descriptor in the pool.
+ */
+static XGL_RESULT desc_pool_get_desc_size(const struct intel_desc_pool *pool,
+ XGL_DESCRIPTOR_TYPE type,
+ struct intel_desc_offset *size)
+{
+ uint32_t surface_size = 0, sampler_size = 0;
+
+ switch (type) {
+ case XGL_DESCRIPTOR_TYPE_SAMPLER:
+ sampler_size = pool->sampler_desc_size;
+ break;
+ case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+ surface_size = pool->surface_desc_size;
+ sampler_size = pool->sampler_desc_size;
+ break;
+ case XGL_DESCRIPTOR_TYPE_TEXTURE:
+ case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_IMAGE:
+ case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ surface_size = pool->surface_desc_size;
+ break;
+ default:
+ assert(!"unknown descriptor type");
+ return XGL_ERROR_INVALID_VALUE;
+ break;
+ }
+
+ intel_desc_offset_set(size, surface_size, sampler_size);
+
+ return XGL_SUCCESS;
+}
+
+XGL_RESULT intel_desc_pool_alloc(struct intel_desc_pool *pool,
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO *info,
+ struct intel_desc_offset *begin,
+ struct intel_desc_offset *end)
+{
+ uint32_t surface_size = 0, sampler_size = 0;
+ struct intel_desc_offset alloc;
+ uint32_t i;
+
+ /* calculate sizes needed */
+ for (i = 0; i < info->count; i++) {
+ const XGL_DESCRIPTOR_TYPE_COUNT *tc = &info->pTypeCount[i];
+ struct intel_desc_offset size;
+ XGL_RESULT ret;
+
+ ret = desc_pool_get_desc_size(pool, tc->type, &size);
+ if (ret != XGL_SUCCESS)
+ return ret;
+
+ surface_size += size.surface * tc->count;
+ sampler_size += size.sampler * tc->count;
+ }
+
+ intel_desc_offset_set(&alloc, surface_size, sampler_size);
+
+ *begin = pool->cur;
+ intel_desc_offset_add(end, &pool->cur, &alloc);
+
+ if (!intel_desc_offset_within(end, &pool->size))
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ /* increment the writer pointer */
+ pool->cur = *end;
+
+ return XGL_SUCCESS;
+}
+
+static void desc_pool_validate_begin_end(const struct intel_desc_pool *pool,
+ const struct intel_desc_offset *begin,
+ const struct intel_desc_offset *end)
+{
+ assert(begin->surface % pool->surface_desc_size == 0 &&
+ begin->sampler % pool->sampler_desc_size == 0);
+ assert(end->surface % pool->surface_desc_size == 0 &&
+ end->sampler % pool->sampler_desc_size == 0);
+ assert(intel_desc_offset_within(end, &pool->size));
+}
+
+void intel_desc_pool_free(struct intel_desc_pool *pool,
+ const struct intel_desc_offset *begin,
+ const struct intel_desc_offset *end)
+{
+ desc_pool_validate_begin_end(pool, begin, end);
+
+ /* is it ok not to reclaim? */
+}
+
+XGL_RESULT intel_desc_pool_begin_update(struct intel_desc_pool *pool,
+ XGL_DESCRIPTOR_UPDATE_MODE mode)
+{
+ /* no-op */
+ return XGL_SUCCESS;
+}
+
+XGL_RESULT intel_desc_pool_end_update(struct intel_desc_pool *pool,
+ struct intel_cmd *cmd)
+{
+ /* No pipelined update. cmd_draw() will do the work. */
+ return XGL_SUCCESS;
+}
+
+void intel_desc_pool_clear(struct intel_desc_pool *pool,
+ const struct intel_desc_offset *begin,
+ const struct intel_desc_offset *end)
+{
+ uint32_t i;
+
+ desc_pool_validate_begin_end(pool, begin, end);
+
+ for (i = begin->surface; i < end->surface; i += pool->surface_desc_size) {
+ struct intel_desc_surface *desc = (struct intel_desc_surface *)
+ ((char *) pool->surfaces + i);
+
+ desc->mem = NULL;
+ desc->type = INTEL_DESC_SURFACE_UNUSED;
+ desc->u.unused = NULL;
+ }
+
+ for (i = begin->sampler; i < end->sampler; i += pool->sampler_desc_size) {
+ struct intel_desc_sampler *desc = (struct intel_desc_sampler *)
+ ((char *) pool->samplers + i);
+
+ desc->sampler = NULL;
+ }
+}
+
+void intel_desc_pool_update(struct intel_desc_pool *pool,
+ const struct intel_desc_offset *begin,
+ const struct intel_desc_offset *end,
+ const struct intel_desc_surface *surfaces,
+ const struct intel_desc_sampler *samplers)
+{
+ desc_pool_validate_begin_end(pool, begin, end);
+
+ if (begin->surface < end->surface) {
+ memcpy((char *) pool->surfaces + begin->surface, surfaces,
+ end->surface - begin->surface);
+ }
+
+ if (begin->sampler < end->sampler) {
+ memcpy((char *) pool->samplers + begin->sampler, samplers,
+ end->sampler - begin->sampler);
+ }
+}
+
+void intel_desc_pool_copy(struct intel_desc_pool *pool,
+ const struct intel_desc_offset *begin,
+ const struct intel_desc_offset *end,
+ const struct intel_desc_offset *src)
+{
+ struct intel_desc_offset src_end;
+ const struct intel_desc_surface *surfaces;
+ const struct intel_desc_sampler *samplers;
+
+ /* no overlap */
+ assert(intel_desc_offset_within(src, begin) ||
+ intel_desc_offset_within(end, src));
+
+ /* no read past pool */
+ intel_desc_offset_sub(&src_end, end, begin);
+ intel_desc_offset_add(&src_end, src, &src_end);
+ assert(intel_desc_offset_within(&src_end, &pool->size));
+
+ surfaces = (const struct intel_desc_surface *)
+ ((const char *) pool->surfaces + src->surface);
+ samplers = (const struct intel_desc_surface *)
+ ((const char *) pool->samplers + src->sampler);
+
+ intel_desc_pool_update(pool, begin, end, surfaces, samplers);
+}
+
+void intel_desc_pool_read_surface(const struct intel_desc_pool *pool,
+ const struct intel_desc_offset *offset,
+ XGL_PIPELINE_SHADER_STAGE stage,
+ const struct intel_mem **mem,
+ bool *read_only,
+ const uint32_t **cmd,
+ uint32_t *cmd_len)
+{
+ const struct intel_desc_surface *desc;
+ struct intel_desc_offset end;
+
+ intel_desc_offset_set(&end,
+ offset->surface + pool->surface_desc_size, offset->sampler);
+ desc_pool_validate_begin_end(pool, offset, &end);
+
+ desc = (const struct intel_desc_surface *)
+ ((const char *) pool->surfaces + offset->surface);
+
+ *mem = desc->mem;
+ *read_only = desc->read_only;
+ switch (desc->type) {
+ case INTEL_DESC_SURFACE_BUF:
+ *cmd = (stage == XGL_SHADER_STAGE_FRAGMENT) ?
+ desc->u.buf->fs_cmd : desc->u.buf->cmd;
+ *cmd_len = desc->u.buf->cmd_len;
+ break;
+ case INTEL_DESC_SURFACE_IMG:
+ *cmd = desc->u.img->cmd;
+ *cmd_len = desc->u.img->cmd_len;
+ break;
+ case INTEL_DESC_SURFACE_UNUSED:
+ default:
+ *cmd = NULL;
+ *cmd_len = 0;
+ break;
+ }
+}
+
+void intel_desc_pool_read_sampler(const struct intel_desc_pool *pool,
+ const struct intel_desc_offset *offset,
+ const struct intel_sampler **sampler)
+{
+ const struct intel_desc_sampler *desc;
+ struct intel_desc_offset end;
+
+ intel_desc_offset_set(&end,
+ offset->surface, offset->sampler + pool->sampler_desc_size);
+ desc_pool_validate_begin_end(pool, offset, &end);
+
+ desc = (const struct intel_desc_sampler *)
+ ((const char *) pool->samplers + offset->sampler);
+
+ *sampler = desc->sampler;
+}
+
+static void desc_region_destroy(struct intel_obj *obj)
+{
+ struct intel_desc_region *region = intel_desc_region_from_obj(obj);
+
+ intel_desc_region_destroy(region);
+}
+
+XGL_RESULT intel_desc_region_create(struct intel_dev *dev,
+ XGL_DESCRIPTOR_REGION_USAGE usage,
+ uint32_t max_sets,
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO *info,
+ struct intel_desc_region **region_ret)
+{
+ struct intel_desc_region *region;
+ XGL_RESULT ret;
+
+ region = (struct intel_desc_region *)
+ intel_base_create(dev, sizeof(*region), dev->base.dbg,
+ XGL_DBG_OBJECT_DESCRIPTOR_REGION, info, 0);
+ if (!region)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ region->dev = dev;
+
+ ret = intel_desc_pool_alloc(dev->desc_pool, info,
+ ®ion->pool_begin, ®ion->pool_end);
+ if (ret != XGL_SUCCESS) {
+ intel_base_destroy(®ion->obj.base);
+ return ret;
+ }
+
+ /* point to head */
+ region->cur = region->pool_begin;
+
+ region->obj.destroy = desc_region_destroy;
+
+ *region_ret = region;
+
+ return XGL_SUCCESS;
+}
+
+void intel_desc_region_destroy(struct intel_desc_region *region)
+{
+ intel_desc_pool_free(region->dev->desc_pool,
+ ®ion->pool_begin, ®ion->pool_end);
+ intel_base_destroy(®ion->obj.base);
+}
+
+XGL_RESULT intel_desc_region_alloc(struct intel_desc_region *region,
+ const struct intel_desc_layout *layout,
+ struct intel_desc_offset *begin,
+ struct intel_desc_offset *end)
+{
+ *begin = region->cur;
+ intel_desc_offset_add(end, ®ion->cur, &layout->pool_size);
+
+ if (!intel_desc_offset_within(end, ®ion->pool_end))
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ /* increment the writer pointer */
+ region->cur = *end;
+
+ return XGL_SUCCESS;
+}
+
+void intel_desc_region_free_all(struct intel_desc_region *region)
+{
+ /* reset to head */
+ region->cur = region->pool_begin;
+}
+
+static void desc_set_destroy(struct intel_obj *obj)
+{
+ struct intel_desc_set *set = intel_desc_set_from_obj(obj);
+
+ intel_desc_set_destroy(set);
+}
+
+XGL_RESULT intel_desc_set_create(struct intel_dev *dev,
+ struct intel_desc_region *region,
+ XGL_DESCRIPTOR_SET_USAGE usage,
+ const struct intel_desc_layout *layout,
+ struct intel_desc_set **set_ret)
+{
+ struct intel_desc_set *set;
+ XGL_RESULT ret;
+
+ set = (struct intel_desc_set *)
+ intel_base_create(dev, sizeof(*set), dev->base.dbg,
+ XGL_DBG_OBJECT_DESCRIPTOR_SET, NULL, 0);
+ if (!set)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ set->pool = dev->desc_pool;
+ ret = intel_desc_region_alloc(region, layout,
+ &set->pool_begin, &set->pool_end);
+ if (ret != XGL_SUCCESS) {
+ intel_base_destroy(&set->obj.base);
+ return ret;
+ }
+
+ set->layout = layout;
+
+ set->obj.destroy = desc_set_destroy;
+
+ *set_ret = set;
+
+ return XGL_SUCCESS;
+}
+
+void intel_desc_set_destroy(struct intel_desc_set *set)
+{
+ intel_base_destroy(&set->obj.base);
+}
+
+static void desc_set_update(struct intel_desc_set *set,
+ const struct intel_desc_layout_iter *iter,
+ const struct intel_desc_surface *surfaces,
+ const struct intel_desc_sampler *samplers)
+{
+ struct intel_desc_offset begin, end;
+
+ intel_desc_offset_add(&begin, &set->pool_begin, &iter->offset_begin);
+ intel_desc_offset_add(&end, &set->pool_begin, &iter->offset_end);
+
+ intel_desc_pool_update(set->pool, &begin, &end, surfaces, samplers);
+}
+
+static bool desc_set_img_layout_read_only(XGL_IMAGE_LAYOUT layout)
+{
+ switch (layout) {
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ return true;
+ default:
+ return false;
+ }
+}
+
+void intel_desc_set_update_samplers(struct intel_desc_set *set,
+ const XGL_UPDATE_SAMPLERS *update)
+{
+ struct intel_desc_layout_iter iter;
+ uint32_t i;
+
+ if (!intel_desc_layout_find_index(set->layout, update->index, &iter))
+ return;
+
+ for (i = 0; i < update->count; i++) {
+ const struct intel_sampler *sampler =
+ intel_sampler((XGL_SAMPLER) update->pSamplers[i]);
+ struct intel_desc_sampler desc;
+
+ if (iter.type != XGL_DESCRIPTOR_TYPE_SAMPLER)
+ break;
+
+ desc.sampler = sampler;
+ desc_set_update(set, &iter, NULL, &desc);
+
+ if (!intel_desc_layout_advance_iter(set->layout, &iter))
+ break;
+ }
+}
+
+void intel_desc_set_update_sampler_textures(struct intel_desc_set *set,
+ const XGL_UPDATE_SAMPLER_TEXTURES *update)
+{
+ struct intel_desc_layout_iter iter;
+ const struct intel_sampler *immutable_sampler = NULL;
+ uint32_t i;
+
+ if (!intel_desc_layout_find_index(set->layout, update->index, &iter))
+ return;
+
+ for (i = 0; i < update->count; i++) {
+ const struct intel_sampler *sampler =
+ intel_sampler(update->pSamplerImageViews[i].pSampler);
+ const XGL_IMAGE_VIEW_ATTACH_INFO *info =
+ update->pSamplerImageViews[i].pImageView;
+ const struct intel_img_view *view = intel_img_view(info->view);
+ struct intel_desc_surface view_desc;
+ struct intel_desc_sampler sampler_desc;
+
+ if (iter.type != XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE)
+ return;
+
+ /* update every immutable sampler once */
+ if (immutable_sampler != iter.range->immutable_sampler) {
+ immutable_sampler = iter.range->immutable_sampler;
+
+ if (immutable_sampler) {
+ struct intel_desc_offset begin, end;
+
+ intel_desc_offset_add(&begin, &set->pool_begin,
+ &iter.offset_begin);
+ intel_desc_offset_set(&end, begin.surface,
+ begin.sampler + set->pool->sampler_desc_size);
+
+ sampler_desc.sampler = immutable_sampler;
+ intel_desc_pool_update(set->pool, &begin, &end,
+ NULL, &sampler_desc);
+ }
+ }
+
+ view_desc.mem = view->img->obj.mem;
+ view_desc.read_only = desc_set_img_layout_read_only(info->layout);
+ view_desc.type = INTEL_DESC_SURFACE_IMG;
+ view_desc.u.img = view;
+
+ sampler_desc.sampler = sampler;
+
+ desc_set_update(set, &iter, &view_desc, &sampler_desc);
+
+ if (!intel_desc_layout_advance_iter(set->layout, &iter))
+ break;
+ }
+}
+
+void intel_desc_set_update_images(struct intel_desc_set *set,
+ const XGL_UPDATE_IMAGES *update)
+{
+ struct intel_desc_layout_iter iter;
+ uint32_t i;
+
+ if (!intel_desc_layout_find_index(set->layout, update->index, &iter))
+ return;
+
+ for (i = 0; i < update->count; i++) {
+ const XGL_IMAGE_VIEW_ATTACH_INFO *info = update->pImageViews[i];
+ const struct intel_img_view *view = intel_img_view(info->view);
+ struct intel_desc_surface desc;
+
+ if (iter.type != update->descriptorType)
+ break;
+
+ desc.mem = view->img->obj.mem;
+ desc.read_only = desc_set_img_layout_read_only(info->layout);
+ desc.type = INTEL_DESC_SURFACE_IMG;
+ desc.u.img = view;
+ desc_set_update(set, &iter, &desc, NULL);
+
+ if (!intel_desc_layout_advance_iter(set->layout, &iter))
+ break;
+ }
+}
+
+void intel_desc_set_update_buffers(struct intel_desc_set *set,
+ const XGL_UPDATE_BUFFERS *update)
+{
+ struct intel_desc_layout_iter iter;
+ uint32_t i;
+
+ if (!intel_desc_layout_find_index(set->layout, update->index, &iter))
+ return;
+
+ for (i = 0; i < update->count; i++) {
+ const XGL_BUFFER_VIEW_ATTACH_INFO *info = update->pBufferViews[i];
+ const struct intel_buf_view *view = intel_buf_view(info->view);
+ struct intel_desc_surface desc;
+
+ if (iter.type != update->descriptorType)
+ break;
+
+ desc.mem = view->buf->obj.mem;
+ desc.read_only = false;
+ desc.type = INTEL_DESC_SURFACE_BUF;
+ desc.u.buf = view;
+ desc_set_update(set, &iter, &desc, NULL);
+
+ if (!intel_desc_layout_advance_iter(set->layout, &iter))
+ break;
+ }
+}
+
+void intel_desc_set_update_as_copy(struct intel_desc_set *set,
+ const XGL_UPDATE_AS_COPY *update)
+{
+ const struct intel_desc_set *src_set =
+ intel_desc_set(update->descriptorSet);
+ struct intel_desc_layout_iter iter, src_iter;
+ struct intel_desc_offset begin, end, src_begin;
+ uint32_t i;
+
+ /* disallow combined sampler textures */
+ if (update->descriptorType == XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE)
+ return;
+
+ /* no update->index? */
+ if (!intel_desc_layout_find_index(set->layout, 0, &iter))
+ return;
+ if (!intel_desc_layout_find_index(src_set->layout,
+ update->descriptorIndex, &src_iter))
+ return;
+
+ intel_desc_offset_add(&begin, &set->pool_begin, &iter.offset_begin);
+ intel_desc_offset_add(&src_begin, &src_set->pool_begin,
+ &src_iter.offset_end);
+
+ /* advance to end */
+ for (i = 0; i < update->count; i++) {
+ if (iter.type != update->descriptorType ||
+ src_iter.type != update->descriptorType ||
+ !intel_desc_layout_advance_iter(set->layout, &iter) ||
+ !intel_desc_layout_advance_iter(src_set->layout, &src_iter))
+ break;
+ }
+ if (i < update->count)
+ return;
+
+ intel_desc_offset_add(&end, &src_set->pool_begin, &iter.offset_end);
+
+ intel_desc_pool_copy(src_set->pool, &begin, &end, &src_begin);
+}
+
+static void desc_layout_destroy(struct intel_obj *obj)
+{
+ struct intel_desc_layout *layout = intel_desc_layout_from_obj(obj);
+
+ intel_desc_layout_destroy(layout);
+}
+
+static XGL_RESULT desc_layout_alloc_ranges(struct intel_desc_layout *layout,
+ const struct intel_desc_pool *pool,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO *info)
+{
+ /* calculate counts */
+ while (info) {
+ if (info->sType !=
+ XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)
+ return XGL_ERROR_INVALID_POINTER;
+
+ switch (info->descriptorType) {
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ layout->dynamic_desc_count += info->count;
+ break;
+ default:
+ break;
+ }
+
+ layout->range_count++;
+ info = info->pNext;
+ }
+
+ layout->ranges = icd_alloc(sizeof(layout->ranges[0]) *
+ layout->range_count, 0, XGL_SYSTEM_ALLOC_INTERNAL);
+ if (!layout->ranges)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ memset(layout->ranges, 0, sizeof(layout->ranges[0]) *
+ layout->range_count);
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT desc_layout_init_ranges(struct intel_desc_layout *layout,
+ const struct intel_desc_pool *pool,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO *info)
+{
+ struct intel_desc_offset offset;
+ uint32_t index, i;
+ XGL_RESULT ret;
+
+ ret = desc_layout_alloc_ranges(layout, pool, info);
+ if (ret != XGL_SUCCESS)
+ return ret;
+
+ if (layout->prior_layout) {
+ index = layout->prior_layout->end;
+ offset = layout->prior_layout->pool_size;
+ } else {
+ index = 0;
+ intel_desc_offset_set(&offset, 0, 0);
+ }
+
+ layout->begin = index;
+
+ /* initialize the ranges */
+ for (i = 0; i < layout->range_count; i++, info = info->pNext) {
+ struct intel_desc_layout_range *range = &layout->ranges[i];
+ struct intel_desc_offset size;
+
+ ret = desc_pool_get_desc_size(pool, info->descriptorType, &size);
+ if (ret != XGL_SUCCESS)
+ return ret;
+
+ /* info->stageFlags does not gain us anything */
+ range->type = info->descriptorType;
+
+ range->begin = index;
+ range->offset = offset;
+
+ if (info->immutableSampler != XGL_NULL_HANDLE) {
+ range->immutable_sampler = intel_sampler(info->immutableSampler);
+ /* do not increment sampler offset */
+ intel_desc_offset_set(&range->increment, size.surface, 0);
+ } else {
+ range->immutable_sampler = NULL;
+ range->increment = size;
+ }
+
+ /* increment index and offset */
+ index += info->count;
+ intel_desc_offset_mad(&size, &range->increment, &size,
+ info->count - 1);
+ intel_desc_offset_add(&offset, &offset, &size);
+
+ range->end = index;
+ }
+
+ layout->end = index;
+ layout->pool_size = offset;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT desc_layout_init_bind_points(struct intel_desc_layout *layout,
+ XGL_FLAGS stage_flags,
+ const uint32_t *bind_points)
+{
+ if (!bind_points)
+ return XGL_ERROR_INVALID_POINTER;
+
+ layout->stage_flags = stage_flags;
+
+ if (stage_flags == XGL_SHADER_STAGE_FLAGS_ALL) {
+ layout->bind_point_vs = *bind_points;
+ layout->bind_point_tcs = *bind_points;
+ layout->bind_point_tes = *bind_points;
+ layout->bind_point_gs = *bind_points;
+ layout->bind_point_fs = *bind_points;
+ layout->bind_point_cs = *bind_points;
+ } else {
+ if (stage_flags & XGL_SHADER_STAGE_FLAGS_VERTEX_BIT)
+ layout->bind_point_vs = *bind_points++;
+ if (stage_flags & XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT)
+ layout->bind_point_tcs = *bind_points++;
+ if (stage_flags & XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT)
+ layout->bind_point_tes = *bind_points++;
+ if (stage_flags & XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT)
+ layout->bind_point_gs = *bind_points++;
+ if (stage_flags & XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT)
+ layout->bind_point_fs = *bind_points++;
+ if (stage_flags & XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT)
+ layout->bind_point_cs = *bind_points++;
+ }
+
+ return XGL_SUCCESS;
+}
+
+XGL_RESULT intel_desc_layout_create(struct intel_dev *dev,
+ XGL_FLAGS stage_flags,
+ const uint32_t *bind_points,
+ const struct intel_desc_layout *prior_layout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO *info,
+ struct intel_desc_layout **layout_ret)
+{
+ struct intel_desc_layout *layout;
+ XGL_RESULT ret;
+
+ layout = (struct intel_desc_layout *)
+ intel_base_create(dev, sizeof(*layout), dev->base.dbg,
+ XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT, info, 0);
+ if (!layout)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ layout->prior_layout = prior_layout;
+
+ ret = desc_layout_init_bind_points(layout, stage_flags, bind_points);
+ if (ret == XGL_SUCCESS)
+ ret = desc_layout_init_ranges(layout, dev->desc_pool, info);
+ if (ret != XGL_SUCCESS) {
+ intel_desc_layout_destroy(layout);
+ return ret;
+ }
+
+ layout->obj.destroy = desc_layout_destroy;
+
+ *layout_ret = layout;
+
+ return XGL_SUCCESS;
+}
+
+void intel_desc_layout_destroy(struct intel_desc_layout *layout)
+{
+ icd_free(layout->ranges);
+ intel_base_destroy(&layout->obj.base);
+}
+
+static void desc_layout_init_iter(const struct intel_desc_layout *sublayout,
+ uint32_t index,
+ struct intel_desc_layout_iter *iter)
+{
+ const struct intel_desc_layout_range *range;
+
+ assert(index >= sublayout->begin && index < sublayout->end);
+
+ /* find the range the index is in */
+ for (range = sublayout->ranges;; range++) {
+ assert(range < sublayout->ranges + sublayout->range_count);
+ if (index < range->end)
+ break;
+ }
+
+ /* current position */
+ iter->sublayout = sublayout;
+ iter->range = range;
+ iter->index = index;
+
+ iter->type = iter->range->type;
+ intel_desc_offset_mad(&iter->offset_begin, &range->increment,
+ &range->offset, iter->index - range->begin);
+ intel_desc_offset_add(&iter->offset_end, &iter->offset_begin,
+ &range->increment);
+}
+
+bool intel_desc_layout_find_bind_point(const struct intel_desc_layout *layout,
+ XGL_PIPELINE_SHADER_STAGE stage,
+ uint32_t set, uint32_t binding,
+ struct intel_desc_layout_iter *iter)
+{
+ /* find the layout at the bind point */
+ switch (stage) {
+#define CASE(stage, s) \
+ case XGL_SHADER_STAGE_ ##stage: \
+ while (layout) { \
+ if ((layout->stage_flags & \
+ XGL_SHADER_STAGE_FLAGS_ ##stage## _BIT) && \
+ layout->bind_point_ ##s == set) \
+ break; \
+ layout = layout->prior_layout; \
+ } \
+ break
+ CASE(VERTEX, vs);
+ CASE(TESS_CONTROL, tcs);
+ CASE(TESS_EVALUATION, tes);
+ CASE(GEOMETRY, gs);
+ CASE(FRAGMENT, fs);
+ CASE(COMPUTE, cs);
+#undef CASE
+ default:
+ assert(!"unknown shader stage");
+ layout = NULL;
+ break;
+ }
+
+ if (!layout || layout->begin + binding >= layout->end) {
+ memset(iter, 0, sizeof(*iter));
+ return false;
+ }
+
+ desc_layout_init_iter(layout, layout->begin + binding, iter);
+
+ return true;
+}
+
+bool intel_desc_layout_find_index(const struct intel_desc_layout *layout,
+ uint32_t index,
+ struct intel_desc_layout_iter *iter)
+{
+ if (index >= layout->begin) {
+ /* out of bound */
+ if (index >= layout->end)
+ layout = NULL;
+ } else {
+ while (true) {
+ layout = layout->prior_layout;
+ if (index >= layout->begin) {
+ assert(index < layout->end);
+ break;
+ }
+ }
+ }
+
+ if (!layout) {
+ memset(iter, 0, sizeof(*iter));
+ return false;
+ }
+
+ desc_layout_init_iter(layout, index, iter);
+
+ return true;
+}
+
+bool intel_desc_layout_advance_iter(const struct intel_desc_layout *layout,
+ struct intel_desc_layout_iter *iter)
+{
+ /* all descriptors traversed */
+ if (!iter->sublayout)
+ return false;
+
+ iter->index++;
+ if (iter->index >= iter->range->end) {
+ /* move to the next range */
+ iter->range++;
+
+ if (iter->range >= iter->sublayout->ranges +
+ iter->sublayout->range_count) {
+ /* find again as the chain is not doubly-linked */
+ const bool ret = intel_desc_layout_find_index(layout,
+ iter->index, iter);
+ if (!ret) {
+ iter->sublayout = NULL;
+ iter->range = NULL;
+ }
+
+ return ret;
+ }
+
+ iter->type = iter->range->type;
+ }
+
+ iter->offset_begin = iter->offset_end;
+ intel_desc_offset_add(&iter->offset_end, &iter->offset_end,
+ &iter->range->increment);
+
+ return true;
+}
+
+XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(
+ XGL_DEVICE device,
+ XGL_FLAGS stageFlags,
+ const XGL_UINT* pSetBindPoints,
+ XGL_DESCRIPTOR_SET_LAYOUT priorSetLayout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pSetLayoutInfoList,
+ XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
+{
+ struct intel_dev *dev = intel_dev(device);
+ struct intel_desc_layout *prior_layout = intel_desc_layout(priorSetLayout);
+
+ return intel_desc_layout_create(dev, stageFlags, pSetBindPoints,
+ prior_layout, pSetLayoutInfoList,
+ (struct intel_desc_layout **) pSetLayout);
+}
+
+XGL_RESULT XGLAPI xglBeginDescriptorRegionUpdate(
+ XGL_DEVICE device,
+ XGL_DESCRIPTOR_UPDATE_MODE updateMode)
+{
+ struct intel_dev *dev = intel_dev(device);
+ struct intel_desc_pool *pool = dev->desc_pool;
+
+ return intel_desc_pool_begin_update(pool, updateMode);
+}
+
+XGL_RESULT XGLAPI xglEndDescriptorRegionUpdate(
+ XGL_DEVICE device,
+ XGL_CMD_BUFFER cmd_)
+{
+ struct intel_dev *dev = intel_dev(device);
+ struct intel_desc_pool *pool = dev->desc_pool;
+ struct intel_cmd *cmd = intel_cmd(cmd_);
+
+ return intel_desc_pool_end_update(pool, cmd);
+}
+
+XGL_RESULT XGLAPI xglCreateDescriptorRegion(
+ XGL_DEVICE device,
+ XGL_DESCRIPTOR_REGION_USAGE regionUsage,
+ XGL_UINT maxSets,
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO* pCreateInfo,
+ XGL_DESCRIPTOR_REGION* pDescriptorRegion)
+{
+ struct intel_dev *dev = intel_dev(device);
+
+ return intel_desc_region_create(dev, regionUsage, maxSets, pCreateInfo,
+ (struct intel_desc_region **) pDescriptorRegion);
+}
+
+XGL_RESULT XGLAPI xglClearDescriptorRegion(
+ XGL_DESCRIPTOR_REGION descriptorRegion)
+{
+ struct intel_desc_region *region = intel_desc_region(descriptorRegion);
+
+ intel_desc_region_free_all(region);
+
+ return XGL_SUCCESS;
+}
+
+XGL_RESULT XGLAPI xglAllocDescriptorSets(
+ XGL_DESCRIPTOR_REGION descriptorRegion,
+ XGL_DESCRIPTOR_SET_USAGE setUsage,
+ XGL_UINT count,
+ const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts,
+ XGL_DESCRIPTOR_SET* pDescriptorSets,
+ XGL_UINT* pCount)
+{
+ struct intel_desc_region *region = intel_desc_region(descriptorRegion);
+ struct intel_dev *dev = region->dev;
+ XGL_RESULT ret = XGL_SUCCESS;
+ uint32_t i;
+
+ for (i = 0; i < count; i++) {
+ const struct intel_desc_layout *layout =
+ intel_desc_layout((XGL_DESCRIPTOR_SET_LAYOUT) pSetLayouts[i]);
+
+ ret = intel_desc_set_create(dev, region, setUsage, layout,
+ (struct intel_desc_set **) &pDescriptorSets[i]);
+ if (ret != XGL_SUCCESS)
+ break;
+ }
+
+ if (pCount)
+ *pCount = i;
+
+ return ret;
+}
+
+XGL_VOID XGLAPI xglClearDescriptorSets(
+ XGL_DESCRIPTOR_REGION descriptorRegion,
+ XGL_UINT count,
+ const XGL_DESCRIPTOR_SET* pDescriptorSets)
+{
+ uint32_t i;
+
+ for (i = 0; i < count; i++) {
+ struct intel_desc_set *set =
+ intel_desc_set((XGL_DESCRIPTOR_SET) pDescriptorSets[i]);
+
+ intel_desc_pool_clear(set->pool, &set->pool_begin, &set->pool_end);
+ }
+}
+
+XGL_VOID XGLAPI xglUpdateDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ const XGL_VOID* pUpdateChain)
+{
+ struct intel_desc_set *set = intel_desc_set(descriptorSet);
+ const union {
+ struct {
+ XGL_STRUCTURE_TYPE sType;
+ const XGL_VOID* pNext;
+ } common;
+
+ XGL_UPDATE_SAMPLERS samplers;
+ XGL_UPDATE_SAMPLER_TEXTURES sampler_textures;
+ XGL_UPDATE_IMAGES images;
+ XGL_UPDATE_BUFFERS buffers;
+ XGL_UPDATE_AS_COPY as_copy;
+ } *u = pUpdateChain;
+
+ while (u) {
+ switch (u->common.sType) {
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ intel_desc_set_update_samplers(set, &u->samplers);
+ break;
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ intel_desc_set_update_sampler_textures(set, &u->sampler_textures);
+ break;
+ case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+ intel_desc_set_update_images(set, &u->images);
+ break;
+ case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ intel_desc_set_update_buffers(set, &u->buffers);
+ break;
+ case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ intel_desc_set_update_as_copy(set, &u->as_copy);
+ break;
+ default:
+ assert(!"unknown descriptor update");
+ break;
+ }
+
+ u = u->common.pNext;
+ }
+}
--- /dev/null
+/*
+ * XGL
+ *
+ * Copyright (C) 2015 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ * Chia-I Wu <olv@lunarg.com>
+ */
+
+#ifndef DESC_H
+#define DESC_H
+
+#include "intel.h"
+#include "obj.h"
+
+struct intel_cmd;
+struct intel_dev;
+
+/**
+ * Opaque descriptors.
+ */
+struct intel_desc_surface;
+struct intel_desc_sampler;
+
+/**
+ * Descriptor pool offset (or size) in bytes.
+ */
+struct intel_desc_offset {
+ uint32_t surface;
+ uint32_t sampler;
+};
+
+/**
+ * Per-device descriptor pool.
+ */
+struct intel_desc_pool {
+ /* this is not an intel_obj */
+
+ uint32_t surface_desc_size;
+ uint32_t sampler_desc_size;
+
+ /* surface descriptors (in system memory until RS is enabled) */
+ struct intel_desc_surface *surfaces;
+ /* sampler desciptors */
+ struct intel_desc_sampler *samplers;
+
+ struct intel_desc_offset size;
+ struct intel_desc_offset cur;
+};
+
+struct intel_desc_region {
+ struct intel_obj obj;
+
+ struct intel_dev *dev;
+
+ /* point to a continuous area in the device's pool */
+ struct intel_desc_offset pool_begin;
+ struct intel_desc_offset pool_end;
+
+ struct intel_desc_offset cur;
+};
+
+struct intel_desc_layout;
+
+struct intel_desc_set {
+ struct intel_obj obj;
+
+ /* suballocated from a region */
+ struct intel_desc_pool *pool;
+ struct intel_desc_offset pool_begin;
+ struct intel_desc_offset pool_end;
+
+ const struct intel_desc_layout *layout;
+};
+
+struct intel_desc_layout {
+ struct intel_obj obj;
+
+ /* a chain of layouts actually */
+ const struct intel_desc_layout *prior_layout;
+
+ /* where this layout binds to in shader stages */
+ XGL_FLAGS stage_flags;
+ uint32_t bind_point_vs;
+ uint32_t bind_point_tcs;
+ uint32_t bind_point_tes;
+ uint32_t bind_point_gs;
+ uint32_t bind_point_fs;
+ uint32_t bind_point_cs;
+
+ /* the continuous area in the descriptor set this layout is for */
+ uint32_t begin;
+ uint32_t end;
+
+ /* homogeneous ranges in this layout */
+ struct intel_desc_layout_range {
+ XGL_DESCRIPTOR_TYPE type;
+ const struct intel_sampler *immutable_sampler;
+
+ /* to speed up intel_desc_layout_advance() */
+ uint32_t begin;
+ uint32_t end;
+ struct intel_desc_offset offset;
+ struct intel_desc_offset increment;
+ } *ranges;
+ uint32_t range_count;
+
+ /* count of _DYNAMIC descriptors */
+ uint32_t dynamic_desc_count;
+
+ /* the size of the entire layout chain in the pool */
+ struct intel_desc_offset pool_size;
+};
+
+struct intel_desc_layout_iter {
+ /* current position in the chain of layouts */
+ const struct intel_desc_layout *sublayout;
+ const struct intel_desc_layout_range *range;
+ uint32_t index;
+
+ XGL_DESCRIPTOR_TYPE type;
+ struct intel_desc_offset offset_begin;
+ struct intel_desc_offset offset_end;
+};
+
+static inline struct intel_desc_region *intel_desc_region(XGL_DESCRIPTOR_REGION region)
+{
+ return (struct intel_desc_region *) region;
+}
+
+static inline struct intel_desc_region *intel_desc_region_from_obj(struct intel_obj *obj)
+{
+ return (struct intel_desc_region *) obj;
+}
+
+static inline struct intel_desc_set *intel_desc_set(XGL_DESCRIPTOR_SET set)
+{
+ return (struct intel_desc_set *) set;
+}
+
+static inline struct intel_desc_set *intel_desc_set_from_obj(struct intel_obj *obj)
+{
+ return (struct intel_desc_set *) obj;
+}
+
+static inline struct intel_desc_layout *intel_desc_layout(XGL_DESCRIPTOR_SET_LAYOUT layout)
+{
+ return (struct intel_desc_layout *) layout;
+}
+
+static inline struct intel_desc_layout *intel_desc_layout_from_obj(struct intel_obj *obj)
+{
+ return (struct intel_desc_layout *) obj;
+}
+
+static inline void intel_desc_offset_set(struct intel_desc_offset *offset,
+ uint32_t surface_offset,
+ uint32_t sampler_offset)
+{
+ offset->surface = surface_offset;
+ offset->sampler = sampler_offset;
+}
+
+static inline void intel_desc_offset_add(struct intel_desc_offset *offset,
+ const struct intel_desc_offset *lhs,
+ const struct intel_desc_offset *rhs)
+{
+ offset->surface = lhs->surface + rhs->surface;
+ offset->sampler = lhs->sampler + rhs->sampler;
+}
+
+static inline void intel_desc_offset_sub(struct intel_desc_offset *offset,
+ const struct intel_desc_offset *lhs,
+ const struct intel_desc_offset *rhs)
+{
+ offset->surface = lhs->surface - rhs->surface;
+ offset->sampler = lhs->sampler - rhs->sampler;
+}
+
+static inline void intel_desc_offset_mad(struct intel_desc_offset *offset,
+ const struct intel_desc_offset *lhs,
+ const struct intel_desc_offset *rhs,
+ uint32_t lhs_scale)
+{
+ offset->surface = lhs->surface * lhs_scale + rhs->surface;
+ offset->sampler = lhs->sampler * lhs_scale + rhs->sampler;
+}
+
+static inline bool intel_desc_offset_within(const struct intel_desc_offset *offset,
+ const struct intel_desc_offset *other)
+{
+ return (offset->surface <= other->surface &&
+ offset->sampler <= other->sampler);
+}
+
+XGL_RESULT intel_desc_pool_create(struct intel_dev *dev,
+ struct intel_desc_pool **pool_ret);
+void intel_desc_pool_destroy(struct intel_desc_pool *pool);
+
+XGL_RESULT intel_desc_pool_alloc(struct intel_desc_pool *pool,
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO *info,
+ struct intel_desc_offset *begin,
+ struct intel_desc_offset *end);
+void intel_desc_pool_free(struct intel_desc_pool *pool,
+ const struct intel_desc_offset *begin,
+ const struct intel_desc_offset *end);
+
+XGL_RESULT intel_desc_pool_begin_update(struct intel_desc_pool *pool,
+ XGL_DESCRIPTOR_UPDATE_MODE mode);
+XGL_RESULT intel_desc_pool_end_update(struct intel_desc_pool *pool,
+ struct intel_cmd *cmd);
+
+void intel_desc_pool_clear(struct intel_desc_pool *pool,
+ const struct intel_desc_offset *begin,
+ const struct intel_desc_offset *end);
+
+void intel_desc_pool_update(struct intel_desc_pool *pool,
+ const struct intel_desc_offset *begin,
+ const struct intel_desc_offset *end,
+ const struct intel_desc_surface *surfaces,
+ const struct intel_desc_sampler *samplers);
+
+void intel_desc_pool_copy(struct intel_desc_pool *pool,
+ const struct intel_desc_offset *begin,
+ const struct intel_desc_offset *end,
+ const struct intel_desc_offset *src);
+
+void intel_desc_pool_read_surface(const struct intel_desc_pool *pool,
+ const struct intel_desc_offset *offset,
+ XGL_PIPELINE_SHADER_STAGE stage,
+ const struct intel_mem **mem,
+ bool *read_only,
+ const uint32_t **cmd,
+ uint32_t *cmd_len);
+void intel_desc_pool_read_sampler(const struct intel_desc_pool *pool,
+ const struct intel_desc_offset *offset,
+ const struct intel_sampler **sampler);
+
+XGL_RESULT intel_desc_region_create(struct intel_dev *dev,
+ XGL_DESCRIPTOR_REGION_USAGE usage,
+ uint32_t max_sets,
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO *info,
+ struct intel_desc_region **region_ret);
+void intel_desc_region_destroy(struct intel_desc_region *region);
+
+XGL_RESULT intel_desc_region_alloc(struct intel_desc_region *region,
+ const struct intel_desc_layout *layout,
+ struct intel_desc_offset *begin,
+ struct intel_desc_offset *end);
+void intel_desc_region_free_all(struct intel_desc_region *region);
+
+XGL_RESULT intel_desc_set_create(struct intel_dev *dev,
+ struct intel_desc_region *region,
+ XGL_DESCRIPTOR_SET_USAGE usage,
+ const struct intel_desc_layout *layout,
+ struct intel_desc_set **set_ret);
+void intel_desc_set_destroy(struct intel_desc_set *set);
+
+void intel_desc_set_update_samplers(struct intel_desc_set *set,
+ const XGL_UPDATE_SAMPLERS *update);
+void intel_desc_set_update_sampler_textures(struct intel_desc_set *set,
+ const XGL_UPDATE_SAMPLER_TEXTURES *update);
+void intel_desc_set_update_images(struct intel_desc_set *set,
+ const XGL_UPDATE_IMAGES *update);
+void intel_desc_set_update_buffers(struct intel_desc_set *set,
+ const XGL_UPDATE_BUFFERS *update);
+void intel_desc_set_update_as_copy(struct intel_desc_set *set,
+ const XGL_UPDATE_AS_COPY *update);
+
+XGL_RESULT intel_desc_layout_create(struct intel_dev *dev,
+ XGL_FLAGS stage_flags,
+ const uint32_t *bind_points,
+ const struct intel_desc_layout *prior_layout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO *info,
+ struct intel_desc_layout **layout_ret);
+void intel_desc_layout_destroy(struct intel_desc_layout *layout);
+
+bool intel_desc_layout_find_bind_point(const struct intel_desc_layout *layout,
+ XGL_PIPELINE_SHADER_STAGE stage,
+ uint32_t set, uint32_t binding,
+ struct intel_desc_layout_iter *iter);
+
+bool intel_desc_layout_find_index(const struct intel_desc_layout *layout,
+ uint32_t index,
+ struct intel_desc_layout_iter *iter);
+
+bool intel_desc_layout_advance_iter(const struct intel_desc_layout *layout,
+ struct intel_desc_layout_iter *iter);
+
+#endif /* DESC_H */
#include <stdarg.h>
#include "kmd/winsys.h"
+#include "desc.h"
#include "gpu.h"
#include "pipeline.h"
#include "queue.h"
return XGL_ERROR_OUT_OF_MEMORY;
}
+ ret = intel_desc_pool_create(dev, &dev->desc_pool);
+ if (ret != XGL_SUCCESS) {
+ intel_dev_destroy(dev);
+ return ret;
+ }
+
ret = dev_create_queues(dev, info->pRequestedQueues,
info->queueRecordCount);
if (ret != XGL_SUCCESS) {
intel_queue_destroy(dev->queues[i]);
}
+ if (dev->desc_pool)
+ intel_desc_pool_destroy(dev->desc_pool);
+
dev_destroy_meta_shaders(dev);
if (dev->cmd_scratch_bo)
#include "gpu.h"
#include "obj.h"
+struct intel_desc_pool;
struct intel_pipeline_shader;
struct intel_queue;
struct intel_winsys;
struct intel_bo *cmd_scratch_bo;
struct intel_pipeline_shader *cmd_meta_shaders[INTEL_DEV_META_SHADER_COUNT];
+ struct intel_desc_pool *desc_pool;
+
struct intel_queue *queues[INTEL_GPU_ENGINE_COUNT];
};
+++ /dev/null
-/*
- * XGL
- *
- * Copyright (C) 2014 LunarG, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- * Chia-I Wu <olv@lunarg.com>
- */
-
-#include "dev.h"
-#include "sampler.h"
-#include "dset.h"
-
-static bool dset_img_state_read_only(XGL_IMAGE_LAYOUT layout)
-{
- switch (layout) {
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
- return true;
- default:
- return false;
- }
-}
-
-static void dset_destroy(struct intel_obj *obj)
-{
- struct intel_dset *dset = intel_dset_from_obj(obj);
-
- intel_dset_destroy(dset);
-}
-
-XGL_RESULT intel_dset_create(struct intel_dev *dev,
- const XGL_DESCRIPTOR_SET_CREATE_INFO *info,
- struct intel_dset **dset_ret)
-{
- struct intel_dset *dset;
-
- dset = (struct intel_dset *) intel_base_create(dev, sizeof(*dset),
- dev->base.dbg, XGL_DBG_OBJECT_DESCRIPTOR_SET, info, 0);
- if (!dset)
- return XGL_ERROR_OUT_OF_MEMORY;
-
- dset->dev = dev;
- dset->slots = icd_alloc(sizeof(dset->slots[0]) * info->slots,
- 0, XGL_SYSTEM_ALLOC_INTERNAL);
- if (!dset->slots) {
- intel_dset_destroy(dset);
- return XGL_ERROR_OUT_OF_MEMORY;
- }
-
- dset->obj.destroy = dset_destroy;
-
- *dset_ret = dset;
-
- return XGL_SUCCESS;
-}
-
-void intel_dset_destroy(struct intel_dset *dset)
-{
- icd_free(dset->slots);
- intel_base_destroy(&dset->obj.base);
-}
-
-ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSet(
- XGL_DEVICE device,
- const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
- XGL_DESCRIPTOR_SET* pDescriptorSet)
-{
- struct intel_dev *dev = intel_dev(device);
-
- return intel_dset_create(dev, pCreateInfo,
- (struct intel_dset **) pDescriptorSet);
-}
-
-ICD_EXPORT XGL_VOID XGLAPI xglBeginDescriptorSetUpdate(
- XGL_DESCRIPTOR_SET descriptorSet)
-{
- /* no-op */
-}
-
-ICD_EXPORT XGL_VOID XGLAPI xglEndDescriptorSetUpdate(
- XGL_DESCRIPTOR_SET descriptorSet)
-{
- /* no-op */
-}
-
-ICD_EXPORT XGL_VOID XGLAPI xglAttachSamplerDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_SAMPLER* pSamplers)
-{
- struct intel_dset *dset = intel_dset(descriptorSet);
- XGL_UINT i;
-
- for (i = 0; i < slotCount; i++) {
- struct intel_dset_slot *slot = &dset->slots[startSlot + i];
- struct intel_sampler *sampler = intel_sampler(pSamplers[i]);
-
- slot->type = INTEL_DSET_SLOT_SAMPLER;
- slot->read_only = true;
- slot->u.sampler = sampler;
- }
-}
-
-ICD_EXPORT XGL_VOID XGLAPI xglAttachImageViewDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews)
-{
- struct intel_dset *dset = intel_dset(descriptorSet);
- XGL_UINT i;
-
- for (i = 0; i < slotCount; i++) {
- struct intel_dset_slot *slot = &dset->slots[startSlot + i];
- const XGL_IMAGE_VIEW_ATTACH_INFO *info = &pImageViews[i];
- struct intel_img_view *view = intel_img_view(info->view);
-
- slot->type = INTEL_DSET_SLOT_IMG_VIEW;
- slot->read_only = dset_img_state_read_only(info->layout);
- slot->u.img_view = view;
- }
-}
-
-ICD_EXPORT XGL_VOID XGLAPI xglAttachBufferViewDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferViews)
-{
- struct intel_dset *dset = intel_dset(descriptorSet);
- XGL_UINT i;
-
- for (i = 0; i < slotCount; i++) {
- struct intel_dset_slot *slot = &dset->slots[startSlot + i];
- const XGL_BUFFER_VIEW_ATTACH_INFO *info = &pBufferViews[i];
-
- slot->type = INTEL_DSET_SLOT_BUF_VIEW;
- slot->read_only = false;
- slot->u.buf_view = intel_buf_view(info->view);
- }
-}
-
-ICD_EXPORT XGL_VOID XGLAPI xglAttachNestedDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets)
-{
- struct intel_dset *dset = intel_dset(descriptorSet);
- XGL_UINT i;
-
- for (i = 0; i < slotCount; i++) {
- struct intel_dset_slot *slot = &dset->slots[startSlot + i];
- const XGL_DESCRIPTOR_SET_ATTACH_INFO *info = &pNestedDescriptorSets[i];
- struct intel_dset *nested = intel_dset(info->descriptorSet);
-
- slot->type = INTEL_DSET_SLOT_NESTED;
- slot->read_only = true;
- slot->u.nested.dset = nested;
- slot->u.nested.slot_offset = info->slotOffset;
- }
-}
-
-ICD_EXPORT XGL_VOID XGLAPI xglClearDescriptorSetSlots(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount)
-{
- struct intel_dset *dset = intel_dset(descriptorSet);
- XGL_UINT i;
-
- for (i = 0; i < slotCount; i++) {
- struct intel_dset_slot *slot = &dset->slots[startSlot + i];
-
- slot->type = INTEL_DSET_SLOT_UNUSED;
- slot->read_only = true;
- slot->u.unused = NULL;
- }
-}
+++ /dev/null
-/*
- * XGL
- *
- * Copyright (C) 2014 LunarG, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- * Chia-I Wu <olv@lunarg.com>
- */
-
-#ifndef DSET_H
-#define DSET_H
-
-#include "intel.h"
-#include "obj.h"
-#include "view.h"
-
-enum intel_dset_slot_type {
- INTEL_DSET_SLOT_UNUSED,
- INTEL_DSET_SLOT_SAMPLER,
- INTEL_DSET_SLOT_IMG_VIEW,
- INTEL_DSET_SLOT_BUF_VIEW,
- INTEL_DSET_SLOT_NESTED,
-};
-
-struct intel_dset;
-
-struct intel_dset_slot {
- enum intel_dset_slot_type type;
- bool read_only;
-
- union {
- const void *unused;
- const struct intel_sampler *sampler;
- const struct intel_img_view *img_view;
-
- struct intel_buf_view *buf_view;
-
- struct {
- const struct intel_dset *dset;
- XGL_UINT slot_offset;
- } nested;
-
- } u;
-};
-
-struct intel_dset {
- struct intel_obj obj;
-
- struct intel_dev *dev;
- struct intel_dset_slot *slots;
-};
-
-static inline struct intel_dset *intel_dset(XGL_DESCRIPTOR_SET dset)
-{
- return (struct intel_dset *) dset;
-}
-
-static inline struct intel_dset *intel_dset_from_obj(struct intel_obj *obj)
-{
- return (struct intel_dset *) obj;
-}
-
-XGL_RESULT intel_dset_create(struct intel_dev *dev,
- const XGL_DESCRIPTOR_SET_CREATE_INFO *info,
- struct intel_dset **dset_ret);
-void intel_dset_destroy(struct intel_dset *dset);
-
-#endif /* DSET_H */
shallow_copy = sizeof(XGL_SAMPLER_CREATE_INFO);
break;
case XGL_DBG_OBJECT_DESCRIPTOR_SET:
- assert(info.header->struct_type == XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO);
- shallow_copy = sizeof(XGL_DESCRIPTOR_SET_CREATE_INFO);
+ /* no create info */
break;
case XGL_DBG_OBJECT_VIEWPORT_STATE:
assert(info.header->struct_type == XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO);
assert(info.header->struct_type == XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);
shallow_copy = sizeof(XGL_RENDER_PASS_CREATE_INFO);
break;
+ case XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT:
+ assert(info.header->struct_type == XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
+ /* TODO */
+ shallow_copy = sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) * 0;
+ break;
+ case XGL_DBG_OBJECT_DESCRIPTOR_REGION:
+ assert(info.header->struct_type == XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO);
+ shallow_copy = sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO);
+ break;
default:
// log debug message regarding invalid struct_type?
intel_dev_log(dbg->dev, XGL_DBG_MSG_ERROR,
}
static XGL_RESULT pipeline_build_shader(struct intel_pipeline *pipeline,
- struct intel_pipeline_shader *sh,
- const XGL_PIPELINE_SHADER *sh_info)
+ const struct intel_desc_layout *layout,
+ const XGL_PIPELINE_SHADER *sh_info,
+ struct intel_pipeline_shader *sh)
{
XGL_RESULT ret;
- ret = intel_pipeline_shader_compile(sh, pipeline->dev->gpu, sh_info);
+ ret = intel_pipeline_shader_compile(sh,
+ pipeline->dev->gpu, layout, sh_info);
if (ret != XGL_SUCCESS)
return ret;
static XGL_RESULT pipeline_build_shaders(struct intel_pipeline *pipeline,
const struct intel_pipeline_create_info *info)
{
+ const struct intel_desc_layout *layout =
+ intel_desc_layout(info->graphics.lastSetLayout);
XGL_RESULT ret = XGL_SUCCESS;
- if (ret == XGL_SUCCESS && info->vs.shader)
- ret = pipeline_build_shader(pipeline, &pipeline->vs, &info->vs);
- if (ret == XGL_SUCCESS && info->tcs.shader)
- ret = pipeline_build_shader(pipeline, &pipeline->tcs, &info->tcs);
- if (ret == XGL_SUCCESS && info->tes.shader)
- ret = pipeline_build_shader(pipeline, &pipeline->tes, &info->tes);
- if (ret == XGL_SUCCESS && info->gs.shader)
- ret = pipeline_build_shader(pipeline, &pipeline->gs, &info->gs);
- if (ret == XGL_SUCCESS && info->fs.shader)
- ret = pipeline_build_shader(pipeline, &pipeline->fs, &info->fs);
-
- if (ret == XGL_SUCCESS && info->compute.cs.shader)
- ret = pipeline_build_shader(pipeline, &pipeline->cs, &info->compute.cs);
+ if (ret == XGL_SUCCESS && info->vs.shader) {
+ ret = pipeline_build_shader(pipeline, layout,
+ &info->vs, &pipeline->vs);
+ }
+ if (ret == XGL_SUCCESS && info->tcs.shader) {
+ ret = pipeline_build_shader(pipeline, layout,
+ &info->tcs,&pipeline->tcs);
+ }
+ if (ret == XGL_SUCCESS && info->tes.shader) {
+ ret = pipeline_build_shader(pipeline, layout,
+ &info->tes,&pipeline->tes);
+ }
+ if (ret == XGL_SUCCESS && info->gs.shader) {
+ ret = pipeline_build_shader(pipeline, layout,
+ &info->gs, &pipeline->gs);
+ }
+ if (ret == XGL_SUCCESS && info->fs.shader) {
+ ret = pipeline_build_shader(pipeline, layout,
+ &info->fs, &pipeline->fs);
+ }
+
+ if (ret == XGL_SUCCESS && info->compute.cs.shader) {
+ layout = intel_desc_layout(info->compute.lastSetLayout);
+ ret = pipeline_build_shader(pipeline, layout,
+ &info->compute.cs, &pipeline->cs);
+ }
return ret;
}
#include "intel.h"
#include "obj.h"
+#include "desc.h"
#include "dev.h"
enum intel_pipeline_shader_use {
INTEL_COMPUTED_DEPTH_MODE_ON_LE
};
-#define INTEL_PIPELINE_RMAP_SLOT_RT ((XGL_UINT) -1)
-#define INTEL_PIPELINE_RMAP_SLOT_DYN ((XGL_UINT) -2)
+enum intel_pipeline_rmap_slot_type {
+ INTEL_PIPELINE_RMAP_UNUSED,
+ INTEL_PIPELINE_RMAP_RT,
+ INTEL_PIPELINE_RMAP_SURFACE,
+ INTEL_PIPELINE_RMAP_SAMPLER,
+};
+
struct intel_pipeline_rmap_slot {
- /*
- *
- * When path_len is 0, the slot is unused.
- * When path_len is 1, the slot uses descriptor "index".
- * When path_len is INTEL_RMAP_SLOT_RT, the slot uses RT "index".
- * When path_len is INTEL_RMAP_SLOT_DYN, the slot uses the dynamic view.
- * Otherwise, the slot uses "path" to find the descriptor.
- */
- XGL_UINT path_len;
+ enum intel_pipeline_rmap_slot_type type;
union {
- XGL_UINT index;
- XGL_UINT *path;
+ uint32_t rt;
+ struct {
+ struct intel_desc_offset offset;
+ int dynamic_offset_index;
+ } surface;
+ struct intel_desc_offset sampler;
} u;
};
XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE_DELTA, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_SAMPLER, XGL_OBJECT)
XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET, XGL_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET_LAYOUT, XGL_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_REGION, XGL_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_MAX_ENUM(_XGL_CHANNEL_SWIZZLE)
} XGL_CHANNEL_SWIZZLE;
-typedef enum _XGL_DESCRIPTOR_SET_SLOT_TYPE
+typedef enum _XGL_DESCRIPTOR_TYPE
{
- XGL_SLOT_UNUSED = 0x00000000,
- XGL_SLOT_SHADER_RESOURCE = 0x00000001,
- XGL_SLOT_SHADER_UAV = 0x00000002,
- XGL_SLOT_SHADER_SAMPLER = 0x00000003,
- XGL_SLOT_NEXT_DESCRIPTOR_SET = 0x00000004,
+ XGL_DESCRIPTOR_TYPE_SAMPLER = 0x00000000,
+ XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE = 0x00000001,
+ XGL_DESCRIPTOR_TYPE_TEXTURE = 0x00000002,
+ XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER = 0x00000003,
+ XGL_DESCRIPTOR_TYPE_IMAGE = 0x00000004,
+ XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER = 0x00000005,
+ XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 0x00000006,
+ XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER = 0x00000007,
+ XGL_DESCRIPTOR_TYPE_RAW_BUFFER = 0x00000008,
+ XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 0x00000009,
+ XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC = 0x0000000a,
+ XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC = 0x0000000b,
- // LUNARG CHANGE BEGIN - differentiate between textures and buffers
- XGL_SLOT_SHADER_TEXTURE_RESOURCE = 0x00000005,
+ XGL_DESCRIPTOR_TYPE_BEGIN_RANGE = XGL_DESCRIPTOR_TYPE_SAMPLER,
+ XGL_DESCRIPTOR_TYPE_END_RANGE = XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC,
+ XGL_NUM_DESCRIPTOR_TYPE = (XGL_DESCRIPTOR_TYPE_END_RANGE - XGL_DESCRIPTOR_TYPE_BEGIN_RANGE + 1),
+ XGL_MAX_ENUM(_XGL_DESCRIPTOR_TYPE)
+} XGL_DESCRIPTOR_TYPE;
- XGL_DESCRIPTOR_SET_SLOT_TYPE_BEGIN_RANGE = XGL_SLOT_UNUSED,
- XGL_DESCRIPTOR_SET_SLOT_TYPE_END_RANGE = XGL_SLOT_SHADER_TEXTURE_RESOURCE,
- // LUNARG CHANGE END
+typedef enum _XGL_DESCRIPTOR_REGION_USAGE
+{
+ XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT = 0x00000000,
+ XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC = 0x00000001,
+
+ XGL_DESCRIPTOR_REGION_USAGE_BEGIN_RANGE = XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT,
+ XGL_DESCRIPTOR_REGION_USAGE_END_RANGE = XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC,
+ XGL_NUM_DESCRIPTOR_REGION_USAGE = (XGL_DESCRIPTOR_REGION_USAGE_END_RANGE - XGL_DESCRIPTOR_REGION_USAGE_BEGIN_RANGE + 1),
+ XGL_MAX_ENUM(_XGL_DESCRIPTOR_REGION_USAGE)
+} XGL_DESCRIPTOR_REGION_USAGE;
+
+typedef enum _XGL_DESCRIPTOR_UPDATE_MODE
+{
+ XGL_DESCRIPTOR_UDPATE_MODE_COPY = 0x00000000,
+ XGL_DESCRIPTOR_UPDATE_MODE_FASTEST = 0x00000001,
+
+ XGL_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE = XGL_DESCRIPTOR_UDPATE_MODE_COPY,
+ XGL_DESCRIPTOR_UPDATE_MODE_END_RANGE = XGL_DESCRIPTOR_UPDATE_MODE_FASTEST,
+ XGL_NUM_DESCRIPTOR_UPDATE_MODE = (XGL_DESCRIPTOR_UPDATE_MODE_END_RANGE - XGL_DESCRIPTOR_UPDATE_MODE_BEGIN_RANGE + 1),
+ XGL_MAX_ENUM(_XGL_DESCRIPTOR_UPDATE_MODE)
+} XGL_DESCRIPTOR_UPDATE_MODE;
+
+typedef enum _XGL_DESCRIPTOR_SET_USAGE
+{
+ XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0x00000000,
+ XGL_DESCRIPTOR_SET_USAGE_STATIC = 0x00000001,
- XGL_NUM_DESCRIPTOR_SET_SLOT_TYPE = (XGL_DESCRIPTOR_SET_SLOT_TYPE_END_RANGE - XGL_DESCRIPTOR_SET_SLOT_TYPE_BEGIN_RANGE + 1),
- XGL_MAX_ENUM(_XGL_DESCRIPTOR_SET_SLOT_TYPE)
-} XGL_DESCRIPTOR_SET_SLOT_TYPE;
+ XGL_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT,
+ XGL_DESCRIPTOR_SET_USAGE_END_RANGE = XGL_DESCRIPTOR_SET_USAGE_STATIC,
+ XGL_NUM_DESCRIPTOR_SET_USAGE = (XGL_DESCRIPTOR_SET_USAGE_END_RANGE - XGL_DESCRIPTOR_SET_USAGE_BEGIN_RANGE + 1),
+ XGL_MAX_ENUM(_XGL_DESCRIPTOR_SET_USAGE)
+} XGL_DESCRIPTOR_SET_USAGE;
typedef enum _XGL_QUERY_TYPE
{
XGL_MAX_ENUM(_XGL_PIPELINE_SHADER_STAGE)
} XGL_PIPELINE_SHADER_STAGE;
+typedef enum _XGL_SHADER_STAGE_FLAGS
+{
+ XGL_SHADER_STAGE_FLAGS_VERTEX_BIT = 0x00000001,
+ XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT = 0x00000002,
+ XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT = 0x00000004,
+ XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT = 0x00000008,
+ XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT = 0x00000010,
+ XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT = 0x00000020,
+
+ XGL_SHADER_STAGE_FLAGS_ALL = 0x7FFFFFFF,
+ XGL_MAX_ENUM(_XGL_SHADER_STAGE_FLAGS)
+} XGL_SHADER_STAGE_FLAGS;
+
// Graphics workload submit type. Used for rendering workloads.
typedef enum _XGL_RENDER_PASS_OPERATION
{
XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO = 12,
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_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 15,
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_MEMORY_BARRIER = 45,
XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 46,
XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 47,
+ XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO = 48,
+ XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS = 49,
+ XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES = 50,
+ XGL_STRUCTURE_TYPE_UPDATE_IMAGES = 51,
+ XGL_STRUCTURE_TYPE_UPDATE_BUFFERS = 52,
+ XGL_STRUCTURE_TYPE_UPDATE_AS_COPY = 53,
XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
} XGL_STRUCTURE_TYPE;
XGL_IMAGE_LAYOUT layout;
} XGL_IMAGE_VIEW_ATTACH_INFO;
+typedef struct _XGL_UPDATE_SAMPLERS
+{
+ XGL_STRUCTURE_TYPE sType;
+ XGL_VOID* pNext;
+ XGL_UINT index;
+ XGL_UINT count;
+ const XGL_SAMPLER* pSamplers;
+} XGL_UPDATE_SAMPLERS;
+
+typedef struct _XGL_SAMPLER_IMAGE_VIEW_INFO
+{
+ XGL_SAMPLER pSampler;
+ const XGL_IMAGE_VIEW_ATTACH_INFO* pImageView;
+} XGL_SAMPLER_IMAGE_VIEW_INFO;
+
+typedef struct _XGL_UPDATE_SAMPLER_TEXTURES
+{
+ XGL_STRUCTURE_TYPE sType;
+ XGL_VOID* pNext;
+ XGL_UINT index;
+ XGL_UINT count;
+ const XGL_SAMPLER_IMAGE_VIEW_INFO* pSamplerImageViews;
+} XGL_UPDATE_SAMPLER_TEXTURES;
+
+typedef struct _XGL_UPDATE_IMAGES
+{
+ XGL_STRUCTURE_TYPE sType;
+ XGL_VOID* pNext;
+ XGL_DESCRIPTOR_TYPE descriptorType;
+ XGL_UINT index;
+ XGL_UINT count;
+ const XGL_IMAGE_VIEW_ATTACH_INFO* const* pImageViews;
+} XGL_UPDATE_IMAGES;
+
+typedef struct _XGL_UPDATE_BUFFERS
+{
+ XGL_STRUCTURE_TYPE sType;
+ XGL_VOID* pNext;
+ XGL_DESCRIPTOR_TYPE descriptorType;
+ XGL_UINT index;
+ XGL_UINT count;
+ const XGL_BUFFER_VIEW_ATTACH_INFO* const* pBufferViews;
+} XGL_UPDATE_BUFFERS;
+
+typedef struct _XGL_UPDATE_AS_COPY
+{
+ XGL_STRUCTURE_TYPE sType;
+ const XGL_VOID* pNext;
+ XGL_DESCRIPTOR_TYPE descriptorType;
+ XGL_DESCRIPTOR_SET descriptorSet;
+ XGL_UINT descriptorIndex;
+ XGL_UINT count;
+} XGL_UPDATE_AS_COPY;
+
typedef struct _XGL_BUFFER_CREATE_INFO
{
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO
XGL_FLAGS flags; // Reserved
} XGL_SHADER_CREATE_INFO;
-struct _XGL_DESCRIPTOR_SET_MAPPING;
+typedef struct _XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
+{
+ XGL_STRUCTURE_TYPE sType;
+ const XGL_VOID* pNext;
+ XGL_DESCRIPTOR_TYPE descriptorType;
+ XGL_UINT count;
+ XGL_FLAGS stageFlags; // XGL_SHADER_STAGE_FLAGS
+ XGL_SAMPLER immutableSampler;
+} XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
-typedef struct _XGL_DESCRIPTOR_SLOT_INFO
+typedef struct _XGL_DESCRIPTOR_TYPE_COUNT
{
- XGL_DESCRIPTOR_SET_SLOT_TYPE slotObjectType;
- union
- {
- XGL_UINT shaderEntityIndex;// Shader IL slot index for given entity type
- const struct _XGL_DESCRIPTOR_SET_MAPPING* pNextLevelSet; // Pointer to next descriptor set level
- };
-} XGL_DESCRIPTOR_SLOT_INFO;
+ XGL_DESCRIPTOR_TYPE type;
+ XGL_UINT count;
+} XGL_DESCRIPTOR_TYPE_COUNT;
-typedef struct _XGL_DESCRIPTOR_SET_MAPPING
+typedef struct _XGL_DESCRIPTOR_REGION_CREATE_INFO
{
- XGL_UINT descriptorCount;
- const XGL_DESCRIPTOR_SLOT_INFO* pDescriptorInfo;
-} XGL_DESCRIPTOR_SET_MAPPING;
+ XGL_STRUCTURE_TYPE sType;
+ const XGL_VOID* pNext;
+ XGL_UINT count;
+ const XGL_DESCRIPTOR_TYPE_COUNT* pTypeCount;
+} XGL_DESCRIPTOR_REGION_CREATE_INFO;
typedef struct _XGL_LINK_CONST_BUFFER
{
const XGL_VOID* pBufferData;
} XGL_LINK_CONST_BUFFER;
-typedef struct _XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO
-{
- XGL_DESCRIPTOR_SET_SLOT_TYPE slotObjectType;
- XGL_UINT shaderEntityIndex;
-} XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO;
-
typedef struct _XGL_PIPELINE_SHADER
{
XGL_PIPELINE_SHADER_STAGE stage;
XGL_SHADER shader;
- 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_PIPELINE_SHADER;
typedef struct _XGL_COMPUTE_PIPELINE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
XGL_PIPELINE_SHADER cs;
XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS
+ XGL_DESCRIPTOR_SET_LAYOUT lastSetLayout;
} XGL_COMPUTE_PIPELINE_CREATE_INFO;
typedef struct _XGL_VERTEX_INPUT_BINDING_DESCRIPTION
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
const XGL_VOID* pNext; // Pointer to next structure
XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS
+ XGL_DESCRIPTOR_SET_LAYOUT lastSetLayout;
} XGL_GRAPHICS_PIPELINE_CREATE_INFO;
typedef struct _XGL_SAMPLER_CREATE_INFO
XGL_BORDER_COLOR_TYPE borderColorType;
} XGL_SAMPLER_CREATE_INFO;
-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_DESCRIPTOR_SET_CREATE_INFO;
-
-typedef struct _XGL_DESCRIPTOR_SET_ATTACH_INFO
-{
- XGL_DESCRIPTOR_SET descriptorSet;
- XGL_UINT slotOffset;
-} XGL_DESCRIPTOR_SET_ATTACH_INFO;
-
typedef struct _XGL_DYNAMIC_VP_STATE_CREATE_INFO
{
XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO
typedef XGL_RESULT (XGLAPI *xglLoadPipelineType)(XGL_DEVICE device, XGL_SIZE dataSize, const XGL_VOID* pData, XGL_PIPELINE* pPipeline);
typedef XGL_RESULT (XGLAPI *xglCreatePipelineDeltaType)(XGL_DEVICE device, XGL_PIPELINE p1, XGL_PIPELINE p2, XGL_PIPELINE_DELTA* delta);
typedef XGL_RESULT (XGLAPI *xglCreateSamplerType)(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler);
-typedef XGL_RESULT (XGLAPI *xglCreateDescriptorSetType)(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET* pDescriptorSet);
-typedef XGL_VOID (XGLAPI *xglBeginDescriptorSetUpdateType)(XGL_DESCRIPTOR_SET descriptorSet);
-typedef XGL_VOID (XGLAPI *xglEndDescriptorSetUpdateType)(XGL_DESCRIPTOR_SET descriptorSet);
-typedef XGL_VOID (XGLAPI *xglAttachSamplerDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_SAMPLER* pSamplers);
-typedef XGL_VOID (XGLAPI *xglAttachImageViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
-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 *xglCreateDescriptorSetLayoutType)(XGL_DEVICE device, XGL_FLAGS stageFlags, const XGL_UINT* pSetBindPoints, XGL_DESCRIPTOR_SET_LAYOUT priorSetLayout, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pSetLayoutInfoList, XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout);
+typedef XGL_RESULT (XGLAPI *xglBeginDescriptorRegionUpdateType)(XGL_DEVICE device, XGL_DESCRIPTOR_UPDATE_MODE updateMode);
+typedef XGL_RESULT (XGLAPI *xglEndDescriptorRegionUpdateType)(XGL_DEVICE device, XGL_CMD_BUFFER cmd);
+typedef XGL_RESULT (XGLAPI *xglCreateDescriptorRegionType)(XGL_DEVICE device, XGL_DESCRIPTOR_REGION_USAGE regionUsage, XGL_UINT maxSets, const XGL_DESCRIPTOR_REGION_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_REGION* pDescriptorRegion);
+typedef XGL_RESULT (XGLAPI *xglClearDescriptorRegionType)(XGL_DESCRIPTOR_REGION descriptorRegion);
+typedef XGL_RESULT (XGLAPI *xglAllocDescriptorSetsType)(XGL_DESCRIPTOR_REGION descriptorRegion, XGL_DESCRIPTOR_SET_USAGE setUsage, XGL_UINT count, const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts, XGL_DESCRIPTOR_SET* pDescriptorSets, XGL_UINT* pCount);
+typedef XGL_VOID (XGLAPI *xglClearDescriptorSetsType)(XGL_DESCRIPTOR_REGION descriptorRegion, XGL_UINT count, const XGL_DESCRIPTOR_SET* pDescriptorSets);
+typedef XGL_VOID (XGLAPI *xglUpdateDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, const XGL_VOID* pUpdateChain);
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_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 *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 *xglCmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET descriptorSet, const XGL_UINT* pUserData);
typedef XGL_VOID (XGLAPI *xglCmdBindVertexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT binding);
typedef XGL_VOID (XGLAPI *xglCmdBindIndexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
typedef XGL_VOID (XGLAPI *xglCmdDrawType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstVertex, XGL_UINT vertexCount, XGL_UINT firstInstance, XGL_UINT instanceCount);
// Descriptor set functions
-XGL_RESULT XGLAPI xglCreateDescriptorSet(
- XGL_DEVICE device,
- const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
- XGL_DESCRIPTOR_SET* pDescriptorSet);
-
-XGL_VOID XGLAPI xglBeginDescriptorSetUpdate(
- XGL_DESCRIPTOR_SET descriptorSet);
-
-XGL_VOID XGLAPI xglEndDescriptorSetUpdate(
- XGL_DESCRIPTOR_SET descriptorSet);
-
-XGL_VOID XGLAPI xglAttachSamplerDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_SAMPLER* pSamplers);
-
-XGL_VOID XGLAPI xglAttachImageViewDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
-
-XGL_VOID XGLAPI xglAttachBufferViewDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferViews);
-
-XGL_VOID XGLAPI xglAttachNestedDescriptors(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount,
- const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
-
-XGL_VOID XGLAPI xglClearDescriptorSetSlots(
- XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT startSlot,
- XGL_UINT slotCount);
+XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(
+ XGL_DEVICE device,
+ XGL_FLAGS stageFlags, // XGL_SHADER_STAGE_FLAGS
+ const XGL_UINT* pSetBindPoints,
+ XGL_DESCRIPTOR_SET_LAYOUT priorSetLayout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pSetLayoutInfoList,
+ XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout);
+
+XGL_RESULT XGLAPI xglBeginDescriptorRegionUpdate(
+ XGL_DEVICE device,
+ XGL_DESCRIPTOR_UPDATE_MODE updateMode);
+
+XGL_RESULT XGLAPI xglEndDescriptorRegionUpdate(
+ XGL_DEVICE device,
+ XGL_CMD_BUFFER cmd);
+
+XGL_RESULT XGLAPI xglCreateDescriptorRegion(
+ XGL_DEVICE device,
+ XGL_DESCRIPTOR_REGION_USAGE regionUsage,
+ XGL_UINT maxSets,
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO* pCreateInfo,
+ XGL_DESCRIPTOR_REGION* pDescriptorRegion);
+
+XGL_RESULT XGLAPI xglClearDescriptorRegion(
+ XGL_DESCRIPTOR_REGION descriptorRegion);
+
+XGL_RESULT XGLAPI xglAllocDescriptorSets(
+ XGL_DESCRIPTOR_REGION descriptorRegion,
+ XGL_DESCRIPTOR_SET_USAGE setUsage,
+ XGL_UINT count,
+ const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts,
+ XGL_DESCRIPTOR_SET* pDescriptorSets,
+ XGL_UINT* pCount);
+
+XGL_VOID XGLAPI xglClearDescriptorSets(
+ XGL_DESCRIPTOR_REGION descriptorRegion,
+ XGL_UINT count,
+ const XGL_DESCRIPTOR_SET* pDescriptorSets);
+
+XGL_VOID XGLAPI xglUpdateDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ const XGL_VOID* pUpdateChain);
// State object functions
XGL_VOID XGLAPI xglCmdBindDescriptorSet(
XGL_CMD_BUFFER cmdBuffer,
XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- XGL_UINT index,
XGL_DESCRIPTOR_SET descriptorSet,
- XGL_UINT slotOffset);
-
-XGL_VOID XGLAPI xglCmdBindDynamicBufferView(
- XGL_CMD_BUFFER cmdBuffer,
- XGL_PIPELINE_BIND_POINT pipelineBindPoint,
- const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferView);
+ const XGL_UINT* pUserData);
XGL_VOID XGLAPI xglCmdBindVertexBuffer(
XGL_CMD_BUFFER cmdBuffer,
XGL_DBG_OBJECT_BUFFER,
XGL_DBG_OBJECT_BUFFER_VIEW,
+ XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT,
+ XGL_DBG_OBJECT_DESCRIPTOR_REGION,
XGL_DBG_OBJECT_TYPE_BEGIN_RANGE = XGL_DBG_OBJECT_UNKNOWN,
XGL_DBG_OBJECT_TYPE_END_RANGE = XGL_DBG_OBJECT_RENDER_PASS,
xglLoadPipelineType LoadPipeline;
xglCreatePipelineDeltaType CreatePipelineDelta;
xglCreateSamplerType CreateSampler;
- xglCreateDescriptorSetType CreateDescriptorSet;
- xglBeginDescriptorSetUpdateType BeginDescriptorSetUpdate;
- xglEndDescriptorSetUpdateType EndDescriptorSetUpdate;
- xglAttachSamplerDescriptorsType AttachSamplerDescriptors;
- xglAttachImageViewDescriptorsType AttachImageViewDescriptors;
- xglAttachBufferViewDescriptorsType AttachBufferViewDescriptors;
- xglAttachNestedDescriptorsType AttachNestedDescriptors;
- xglClearDescriptorSetSlotsType ClearDescriptorSetSlots;
+ xglCreateDescriptorSetLayoutType CreateDescriptorSetLayout;
+ xglBeginDescriptorRegionUpdateType BeginDescriptorRegionUpdate;
+ xglEndDescriptorRegionUpdateType EndDescriptorRegionUpdate;
+ xglCreateDescriptorRegionType CreateDescriptorRegion;
+ xglClearDescriptorRegionType ClearDescriptorRegion;
+ xglAllocDescriptorSetsType AllocDescriptorSets;
+ xglClearDescriptorSetsType ClearDescriptorSets;
+ xglUpdateDescriptorsType UpdateDescriptors;
xglCreateDynamicViewportStateType CreateDynamicViewportState;
xglCreateDynamicRasterStateType CreateDynamicRasterState;
xglCreateDynamicColorBlendStateType CreateDynamicColorBlendState;
xglCmdBindPipelineDeltaType CmdBindPipelineDelta;
xglCmdBindDynamicStateObjectType CmdBindDynamicStateObject;
xglCmdBindDescriptorSetType CmdBindDescriptorSet;
- xglCmdBindDynamicBufferViewType CmdBindDynamicBufferView;
xglCmdBindVertexBufferType CmdBindVertexBuffer;
xglCmdBindIndexBufferType CmdBindIndexBuffer;
xglCmdDrawType CmdDraw;
cmdBuffer->BindStateObject(XGL_STATE_BIND_VIEWPORT, m_stateViewport);
cmdBuffer->BindStateObject(XGL_STATE_BIND_COLOR_BLEND, m_colorBlend);
cmdBuffer->BindStateObject(XGL_STATE_BIND_DEPTH_STENCIL, m_stateDepthStencil);
+ descriptorSet->CreateXGLDescriptorSet(cmdBuffer);
pipelineobj->CreateXGLPipeline(descriptorSet);
cmdBuffer->BindPipeline(pipelineobj->GetPipelineHandle());
- descriptorSet->CreateXGLDescriptorSet();
cmdBuffer->BindDescriptorSet(descriptorSet->GetDescriptorSetHandle());
}
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
- vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &constantBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&constantBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &constantBuffer);
m_memoryRefManager.AddMemoryRef(&constantBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&meshBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&meshBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&meshBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&meshBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&meshBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
- vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &MVPBuffer);
-
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
// Create descriptor set and attach the constant buffer to it
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&MVPBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &MVPBuffer);
m_memoryRefManager.AddMemoryRef(&MVPBuffer);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&meshBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&meshBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer);
XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
- vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &MVPBuffer);
-
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
pipelineobj.SetDepthStencil(&ds_state);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&MVPBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &MVPBuffer);
m_memoryRefManager.AddMemoryRef(&meshBuffer);
m_memoryRefManager.AddMemoryRef(&MVPBuffer);
XglSamplerObj sampler(m_device);
XglTextureObj texture(m_device);
- vs.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture);
- vs.BindShaderEntitySlotToSampler(0, &sampler);
-
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachImageView(&texture);
- descriptorSet.AttachSampler(&sampler);
+ descriptorSet.AppendSamplerTexture(&sampler, &texture);
m_memoryRefManager.AddMemoryRef(&texture);
XglSamplerObj sampler(m_device);
XglTextureObj texture(m_device);
- ps.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture);
- ps.BindShaderEntitySlotToSampler(0, &sampler);
-
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachImageView(&texture);
- descriptorSet.AttachSampler(&sampler);
+ descriptorSet.AppendSamplerTexture(&sampler, &texture);
m_memoryRefManager.AddMemoryRef(&texture);
XglSamplerObj sampler(m_device);
XglTextureObj texture(m_device);
- ps.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture);
- ps.BindShaderEntitySlotToSampler(0, &sampler);
-
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachImageView(&texture);
- descriptorSet.AttachSampler(&sampler);
+ descriptorSet.AppendSamplerTexture(&sampler, &texture);
m_memoryRefManager.AddMemoryRef(&texture);
XglSamplerObj sampler(m_device);
XglTextureObj texture(m_device);
- ps.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture);
- ps.BindShaderEntitySlotToSampler(0, &sampler);
-
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachImageView(&texture);
- descriptorSet.AttachSampler(&sampler);
+ descriptorSet.AppendSamplerTexture(&sampler, &texture);
m_memoryRefManager.AddMemoryRef(&texture);
XglTextureObj texture3(m_device); // Blue
texture3.ChangeColors(0xff0000ff,0xff0000ff);
- ps.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture1);
- ps.BindShaderEntitySlotToSampler(0, &sampler1);
-
- ps.BindShaderEntitySlotToImage(1, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture2);
- ps.BindShaderEntitySlotToSampler(1, &sampler2);
-
- ps.BindShaderEntitySlotToImage(12, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture3);
- ps.BindShaderEntitySlotToSampler(12, &sampler3);
-
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachImageView(&texture1);
- descriptorSet.AttachSampler(&sampler1);
- descriptorSet.AttachImageView(&texture2);
- descriptorSet.AttachSampler(&sampler2);
- descriptorSet.AttachImageView(&texture3);
- descriptorSet.AttachSampler(&sampler3);
+ descriptorSet.AppendSamplerTexture(&sampler1, &texture1);
+ descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
+ for (int i = 0; i < 10; i++)
+ descriptorSet.AppendDummy();
+ descriptorSet.AppendSamplerTexture(&sampler3, &texture3);
m_memoryRefManager.AddMemoryRef(&texture1);
m_memoryRefManager.AddMemoryRef(&texture2);
1.0, 1.0, 1.0, 1.0 };
XglConstantBufferObj colorBuffer(m_device, valCount, sizeof(bufferVals[0]), (const void*) bufferVals);
- vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &colorBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&colorBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &colorBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
XglCommandBufferObj cmdBuffer(m_device);
"layout (std140, binding = 0) uniform redVal { vec4 color; } myRedVal\n;"
"layout (std140, binding = 1) uniform greenVal { vec4 color; } myGreenVal\n;"
"layout (std140, binding = 2) uniform blueVal { vec4 color; } myBlueVal\n;"
- "layout (std140, binding = 18) uniform whiteVal { vec4 color; } myWhiteVal\n;"
+ "layout (std140, binding = 3) uniform whiteVal { vec4 color; } myWhiteVal\n;"
"void main() {\n"
" gl_FragColor = myBlueVal.color;\n"
" gl_FragColor += myRedVal.color;\n"
// layout (std140, binding = 0) uniform bufferVals { vec4 red; } myRedVal;
// layout (std140, binding = 1) uniform bufferVals { vec4 green; } myGreenVal;
// layout (std140, binding = 2) uniform bufferVals { vec4 blue; } myBlueVal;
- // layout (std140, binding = 18) uniform bufferVals { vec4 white; } myWhiteVal;
+ // layout (std140, binding = 3) uniform bufferVals { vec4 white; } myWhiteVal;
const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 };
const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 };
const int whiteCount = sizeof(whiteVals) / sizeof(float);
XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- ps.BindShaderEntitySlotToBuffer(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- ps.BindShaderEntitySlotToBuffer(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
- ps.BindShaderEntitySlotToBuffer(18, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&redBuffer);
- descriptorSet.AttachBufferView(&greenBuffer);
- descriptorSet.AttachBufferView(&blueBuffer);
- descriptorSet.AttachBufferView(&whiteBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
XglCommandBufferObj cmdBuffer(m_device);
"layout (std140, binding = 0) uniform redVal { vec4 red; };"
"layout (std140, binding = 1) uniform greenVal { vec4 green; };"
"layout (std140, binding = 2) uniform blueVal { vec4 blue; };"
- "layout (std140, binding = 18) uniform whiteVal { vec4 white; };"
+ "layout (std140, binding = 3) uniform whiteVal { vec4 white; };"
"layout (location = 0) out vec4 outColor;\n"
"void main() {\n"
" outColor = blue;\n"
const int whiteCount = sizeof(whiteVals) / sizeof(float);
XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- ps.BindShaderEntitySlotToBuffer(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- ps.BindShaderEntitySlotToBuffer(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
- ps.BindShaderEntitySlotToBuffer(18, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&redBuffer);
- descriptorSet.AttachBufferView(&greenBuffer);
- descriptorSet.AttachBufferView(&blueBuffer);
- descriptorSet.AttachBufferView(&whiteBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
XglCommandBufferObj cmdBuffer(m_device);
"#version 140\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
- "layout (binding=0) uniform sampler2D surface;\n"
+ "layout (binding=1) uniform sampler2D surface;\n"
"layout (location=0) out vec4 outColor;\n"
"layout (location=0) in vec2 UV;\n"
"void main() {\n"
XglSamplerObj sampler(m_device);
XglTextureObj texture(m_device);
- // vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_VERTEX_INPUT, (XGL_OBJECT) &meshBuffer.m_constantBufferView);
- vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &mvpBuffer);
- ps.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture);
- ps.BindShaderEntitySlotToSampler(0, &sampler);
-
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
-
- descriptorSet.AttachBufferView(&mvpBuffer);
- descriptorSet.AttachImageView(&texture);
- descriptorSet.AttachSampler(&sampler);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &mvpBuffer);
+ descriptorSet.AppendSamplerTexture(&sampler, &texture);
m_memoryRefManager.AddMemoryRef(&meshBuffer);
m_memoryRefManager.AddMemoryRef(&mvpBuffer);
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout (binding = 0) uniform sampler2D surface0;\n"
- "layout (binding = 9) uniform sampler2D surface1;\n"
- "layout (binding = 2) uniform sampler2D surface2;\n"
- "layout (binding = 4) uniform sampler2D surface3;\n"
+ "layout (binding = 3) uniform sampler2D surface1;\n"
+ "layout (binding = 1) uniform sampler2D surface2;\n"
+ "layout (binding = 2) uniform sampler2D surface3;\n"
- "layout (std140, binding = 10) uniform redVal { vec4 red; };"
- "layout (std140, binding = 15) uniform greenVal { vec4 green; };"
- "layout (std140, binding = 13) uniform blueVal { vec4 blue; };"
- "layout (std140, binding = 17) uniform whiteVal { vec4 white; };"
+ "layout (std140, binding = 4) uniform redVal { vec4 red; };"
+ "layout (std140, binding = 6) uniform greenVal { vec4 green; };"
+ "layout (std140, binding = 5) uniform blueVal { vec4 blue; };"
+ "layout (std140, binding = 7) uniform whiteVal { vec4 white; };"
"layout (location = 0) out vec4 outColor;\n"
"void main() {\n"
" outColor = red * vec4(0.00001);\n"
const int whiteCount = sizeof(whiteVals) / sizeof(float);
XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- ps.BindShaderEntitySlotToBuffer(10, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
-
XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- ps.BindShaderEntitySlotToBuffer(15, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
-
XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- ps.BindShaderEntitySlotToBuffer(13, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
-
XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
- ps.BindShaderEntitySlotToBuffer(17, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
XglSamplerObj sampler0(m_device);
XglTextureObj texture0(m_device); // Light Red
texture0.ChangeColors(0xff800000,0xff800000);
- ps.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture0);
- ps.BindShaderEntitySlotToSampler(0, &sampler0);
XglSamplerObj sampler2(m_device);
XglTextureObj texture2(m_device); // Light Blue
texture2.ChangeColors(0xff000080,0xff000080);
- ps.BindShaderEntitySlotToImage(2, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture2);
- ps.BindShaderEntitySlotToSampler(2, &sampler2);
XglSamplerObj sampler4(m_device);
XglTextureObj texture4(m_device); // Light Green
texture4.ChangeColors(0xff008000,0xff008000);
- ps.BindShaderEntitySlotToImage(4, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture4);
- ps.BindShaderEntitySlotToSampler(4, &sampler4);
// NOTE: Bindings 1,3,5,7,8,9,11,12,14,16 work for this sampler, but 6 does not!!!
// TODO: Get back here ASAP and understand why.
XglSamplerObj sampler7(m_device);
XglTextureObj texture7(m_device); // Red and Blue
texture7.ChangeColors(0xffff00ff,0xffff00ff);
- ps.BindShaderEntitySlotToImage(9, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture7);
- ps.BindShaderEntitySlotToSampler(9, &sampler7);
-
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&redBuffer);
- descriptorSet.AttachBufferView(&greenBuffer);
- descriptorSet.AttachBufferView(&blueBuffer);
- descriptorSet.AttachBufferView(&whiteBuffer);
- descriptorSet.AttachImageView(&texture0);
- descriptorSet.AttachSampler(&sampler0);
- descriptorSet.AttachImageView(&texture2);
- descriptorSet.AttachSampler(&sampler2);
- descriptorSet.AttachImageView(&texture4);
- descriptorSet.AttachSampler(&sampler4);
- descriptorSet.AttachImageView(&texture7);
- descriptorSet.AttachSampler(&sampler7);
+ descriptorSet.AppendSamplerTexture(&sampler0, &texture0);
+ descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
+ descriptorSet.AppendSamplerTexture(&sampler4, &texture4);
+ descriptorSet.AppendSamplerTexture(&sampler7, &texture7);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer);
+ // swap blue and green
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer);
m_memoryRefManager.AddMemoryRef(&texture0);
m_memoryRefManager.AddMemoryRef(&texture2);
"layout (binding = 1) uniform sampler2D surface1;\n"
"layout (binding = 2) uniform sampler2D surface2;\n"
"layout (binding = 3) uniform sampler2D surface3;\n"
- "layout (std140, binding = 0) uniform redVal { vec4 red; };"
- "layout (std140, binding = 1) uniform greenVal { vec4 green; };"
- "layout (std140, binding = 2) uniform blueVal { vec4 blue; };"
- "layout (std140, binding = 3) uniform whiteVal { vec4 white; };"
+ "layout (std140, binding = 4) uniform redVal { vec4 red; };"
+ "layout (std140, binding = 5) uniform greenVal { vec4 green; };"
+ "layout (std140, binding = 6) uniform blueVal { vec4 blue; };"
+ "layout (std140, binding = 7) uniform whiteVal { vec4 white; };"
"layout (location = 0) out vec4 outColor;\n"
"void main() {\n"
" outColor = red;// * vec4(0.00001);\n"
const int whiteCount = sizeof(whiteVals) / sizeof(float);
XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
- ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
-
XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
- ps.BindShaderEntitySlotToBuffer(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
-
XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
- ps.BindShaderEntitySlotToBuffer(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
-
XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
- ps.BindShaderEntitySlotToBuffer(3, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
XglSamplerObj sampler0(m_device);
XglTextureObj texture0(m_device); // Light Red
texture0.ChangeColors(0xff800000,0xff800000);
- ps.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture0);
- ps.BindShaderEntitySlotToSampler(0, &sampler0);
XglSamplerObj sampler2(m_device);
XglTextureObj texture2(m_device); // Light Blue
texture2.ChangeColors(0xff000080,0xff000080);
- ps.BindShaderEntitySlotToImage(1, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture2);
- ps.BindShaderEntitySlotToSampler(1, &sampler2);
XglSamplerObj sampler4(m_device);
XglTextureObj texture4(m_device); // Light Green
texture4.ChangeColors(0xff008000,0xff008000);
- ps.BindShaderEntitySlotToImage(2, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture4);
- ps.BindShaderEntitySlotToSampler(2, &sampler4);
XglSamplerObj sampler7(m_device);
XglTextureObj texture7(m_device); // Red and Blue
texture7.ChangeColors(0xffff00ff,0xffff00ff);
- ps.BindShaderEntitySlotToImage(3, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture7);
- ps.BindShaderEntitySlotToSampler(3, &sampler7);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&redBuffer);
- descriptorSet.AttachBufferView(&greenBuffer);
- descriptorSet.AttachBufferView(&blueBuffer);
- descriptorSet.AttachBufferView(&whiteBuffer);
- descriptorSet.AttachImageView(&texture0);
- descriptorSet.AttachSampler(&sampler0);
- descriptorSet.AttachImageView(&texture2);
- descriptorSet.AttachSampler(&sampler2);
- descriptorSet.AttachImageView(&texture4);
- descriptorSet.AttachSampler(&sampler4);
- descriptorSet.AttachImageView(&texture7);
- descriptorSet.AttachSampler(&sampler7);
+ descriptorSet.AppendSamplerTexture(&sampler0, &texture0);
+ descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
+ descriptorSet.AppendSamplerTexture(&sampler4, &texture4);
+ descriptorSet.AppendSamplerTexture(&sampler7, &texture7);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer);
m_memoryRefManager.AddMemoryRef(&texture0);
m_memoryRefManager.AddMemoryRef(&texture2);
XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
XglConstantBufferObj mixedBuffer(m_device, constCount, sizeof(mixedVals[0]), (const void*) mixedVals);
- vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &mixedBuffer);
- ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &mixedBuffer);
XglPipelineObj pipelineobj(m_device);
pipelineobj.AddShader(&vs);
pipelineobj.AddShader(&ps);
XglDescriptorSetObj descriptorSet(m_device);
- descriptorSet.AttachBufferView(&mixedBuffer);
+ descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &mixedBuffer);
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
XglCommandBufferObj cmdBuffer(m_device);
}
-void XglDescriptorSetObj::AttachBufferView(XglConstantBufferObj *constantBuffer)
+XglDescriptorSetObj::~XglDescriptorSetObj()
{
- m_bufferViews.push_back(&constantBuffer->m_bufferViewInfo);
- m_bufferSlots.push_back(m_nextSlot);
- m_nextSlot++;
-
+ delete m_set;
}
-void XglDescriptorSetObj::AttachSampler(XglSamplerObj *sampler)
+int XglDescriptorSetObj::AppendDummy()
{
- m_samplers.push_back(sampler);
- m_samplerSlots.push_back(m_nextSlot);
- m_nextSlot++;
+ /* request a descriptor but do not update it */
+ XGL_DESCRIPTOR_TYPE_COUNT tc = {};
+ tc.type = XGL_DESCRIPTOR_TYPE_RAW_BUFFER;
+ tc.count = 1;
+ m_type_counts.push_back(tc);
+ return m_nextSlot++;
}
-void XglDescriptorSetObj::AttachImageView(XglTextureObj *texture)
+int XglDescriptorSetObj::AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj *constantBuffer)
{
- m_imageViews.push_back(&texture->m_textureViewInfo);
- m_imageSlots.push_back(m_nextSlot);
- m_nextSlot++;
+ XGL_DESCRIPTOR_TYPE_COUNT tc = {};
+ tc.type = type;
+ tc.count = 1;
+ m_type_counts.push_back(tc);
-}
+ m_bufferInfo.push_back(&constantBuffer->m_bufferViewInfo);
-XGL_DESCRIPTOR_SLOT_INFO* XglDescriptorSetObj::GetSlotInfo(vector<int>slots,
- vector<XGL_DESCRIPTOR_SET_SLOT_TYPE>types,
- vector<void *>objs )
-{
- int nSlots = m_bufferSlots.size() + m_imageSlots.size() + m_samplerSlots.size();
- m_slotInfo = (XGL_DESCRIPTOR_SLOT_INFO*) malloc( nSlots * sizeof(XGL_DESCRIPTOR_SLOT_INFO) );
- memset(m_slotInfo,0,nSlots*sizeof(XGL_DESCRIPTOR_SLOT_INFO));
-
- for (int i=0; i<nSlots; i++)
- {
- m_slotInfo[i].slotObjectType = XGL_SLOT_UNUSED;
- }
-
- for (int i=0; i<slots.size(); i++)
- {
- for (int j=0; j<m_bufferSlots.size(); j++)
- {
- if ( m_bufferViews[j] == objs[i])
- {
- m_slotInfo[m_bufferSlots[j]].shaderEntityIndex = slots[i];
- m_slotInfo[m_bufferSlots[j]].slotObjectType = types[i];
- }
- }
- for (int j=0; j<m_imageSlots.size(); j++)
- {
- if ( m_imageViews[j] == objs[i])
- {
- m_slotInfo[m_imageSlots[j]].shaderEntityIndex = slots[i];
- m_slotInfo[m_imageSlots[j]].slotObjectType = types[i];
- }
- }
- for (int j=0; j<m_samplerSlots.size(); j++)
- {
- if ( m_samplers[j] == objs[i])
- {
- m_slotInfo[m_samplerSlots[j]].shaderEntityIndex = slots[i];
- m_slotInfo[m_samplerSlots[j]].slotObjectType = types[i];
- }
- }
- }
-
- // for (int i=0;i<nSlots;i++)
- // {
- // printf("SlotInfo[%d]: Index = %d, Type = %d\n",i,m_slotInfo[i].shaderEntityIndex, m_slotInfo[i].slotObjectType);
- // fflush(stdout);
- // }
-
- return(m_slotInfo);
+ m_updateBuffers.push_back(xgl_testing::DescriptorSet::update(type, m_nextSlot, 1,
+ (const XGL_BUFFER_VIEW_ATTACH_INFO **) NULL));
+ return m_nextSlot++;
}
-void XglDescriptorSetObj::CreateXGLDescriptorSet()
+
+int XglDescriptorSetObj::AppendSamplerTexture( XglSamplerObj* sampler, XglTextureObj* texture)
{
- init(*m_device, xgl_testing::DescriptorSet::create_info(m_nextSlot));
+ XGL_DESCRIPTOR_TYPE_COUNT tc = {};
+ tc.type = XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE;
+ tc.count = 1;
+ m_type_counts.push_back(tc);
- begin();
- clear();
+ XGL_SAMPLER_IMAGE_VIEW_INFO tmp = {};
+ tmp.pSampler = sampler->obj();
+ tmp.pImageView = &texture->m_textureViewInfo;
+ m_samplerTextureInfo.push_back(tmp);
- for (int i=0; i<m_bufferViews.size();i++)
- {
- attach(m_bufferSlots[i], *m_bufferViews[i]);
- }
- for (int i=0; i<m_samplers.size();i++)
- {
- attach(m_samplerSlots[i], *m_samplers[i]);
- }
- for (int i=0; i<m_imageViews.size();i++)
- {
- attach(m_imageSlots[i], *m_imageViews[i]);
- }
+ m_updateSamplerTextures.push_back(xgl_testing::DescriptorSet::update(m_nextSlot, 1,
+ (const XGL_SAMPLER_IMAGE_VIEW_INFO *) NULL));
- end();
+ return m_nextSlot++;
}
-XGL_DESCRIPTOR_SET XglDescriptorSetObj::GetDescriptorSetHandle()
+XGL_DESCRIPTOR_SET_LAYOUT XglDescriptorSetObj::GetLayout()
{
- return obj();
+ return m_layout.obj();
}
-int XglDescriptorSetObj::GetTotalSlots()
+XGL_DESCRIPTOR_SET XglDescriptorSetObj::GetDescriptorSetHandle()
{
- return m_nextSlot;
+ return m_set->obj();
}
-void XglDescriptorSetObj::BindCommandBuffer(XGL_CMD_BUFFER commandBuffer)
+void XglDescriptorSetObj::CreateXGLDescriptorSet(XglCommandBufferObj *cmdBuffer)
{
- init(*m_device, xgl_testing::DescriptorSet::create_info(m_nextSlot));
+ // create XGL_DESCRIPTOR_REGION
+ XGL_DESCRIPTOR_REGION_CREATE_INFO region = {};
+ region.sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO;
+ region.count = m_type_counts.size();
+ region.pTypeCount = &m_type_counts[0];
+ init(*m_device, XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT, 1, region);
- begin();
- clear();
+ // create XGL_DESCRIPTOR_SET_LAYOUT
+ vector<XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO> layout;
+ layout.resize(m_type_counts.size());
+ for (int i = 0; i < m_type_counts.size(); i++) {
+ layout[i].sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+ layout[i].descriptorType = m_type_counts[i].type;
+ layout[i].count = m_type_counts[i].count;
+ layout[i].stageFlags = XGL_SHADER_STAGE_FLAGS_ALL;
+ layout[i].immutableSampler = XGL_NULL_HANDLE;
- for (int i=0; i<m_bufferViews.size();i++)
- {
- attach(m_bufferSlots[i], *m_bufferViews[i]);
+ if (i < m_type_counts.size() - 1)
+ layout[i].pNext = &layout[i + 1];
+ else
+ layout[i].pNext = NULL;
}
- for (int i=0; i<m_samplers.size();i++)
- {
- attach(m_samplerSlots[i], *m_samplers[i]);
- }
- for (int i=0; i<m_imageViews.size();i++)
- {
- attach(m_imageSlots[i], *m_imageViews[i]);
+
+ m_layout.init(*m_device, 0, layout[0]);
+
+ // create XGL_DESCRIPTOR_SET
+ m_set = alloc_sets(XGL_DESCRIPTOR_SET_USAGE_STATIC, m_layout);
+
+ // build the update chain
+ for (int i = 0; i < m_updateBuffers.size(); i++) {
+ m_updateBuffers[i].pBufferViews = &m_bufferInfo[i];
+
+ if (i < m_updateBuffers.size() - 1)
+ m_updateBuffers[i].pNext = &m_updateBuffers[i + 1];
+ else if (m_updateSamplerTextures.empty())
+ m_updateBuffers[i].pNext = NULL;
+ else
+ m_updateBuffers[i].pNext = &m_updateSamplerTextures[0];
}
+ for (int i = 0; i < m_updateSamplerTextures.size(); i++) {
+ m_updateSamplerTextures[i].pSamplerImageViews = &m_samplerTextureInfo[i];
- end();
+ if (i < m_updateSamplerTextures.size() - 1)
+ m_updateSamplerTextures[i].pNext = &m_updateSamplerTextures[i + 1];
+ else
+ m_updateSamplerTextures[i].pNext = NULL;
+ }
+ const void *chain = (!m_updateBuffers.empty()) ? (const void *) &m_updateBuffers[0] :
+ (!m_updateSamplerTextures.empty()) ? (const void *) &m_updateSamplerTextures[0] :
+ NULL;
- // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic buffer view)
- xglCmdBindDescriptorSet(commandBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, obj(), 0 );
+ // do the updates
+ m_device->begin_descriptor_region_update(XGL_DESCRIPTOR_UPDATE_MODE_FASTEST);
+ clear_sets(*m_set);
+ m_set->update(chain);
+ m_device->end_descriptor_region_update(*cmdBuffer);
}
XglImage::XglImage(XglDevice *dev)
return m_indexType;
}
-XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* XglShaderObj::GetStageCreateInfo(XglDescriptorSetObj *descriptorSet)
+XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* XglShaderObj::GetStageCreateInfo()
{
- XGL_DESCRIPTOR_SLOT_INFO *slotInfo;
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO *stageInfo = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) calloc( 1,sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO) );
stageInfo->sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stageInfo->shader.stage = m_stage;
stageInfo->shader.shader = obj();
- stageInfo->shader.descriptorSetMappingCount = 1;
- stageInfo->shader.pDescriptorSetMapping = (XGL_DESCRIPTOR_SET_MAPPING *)malloc(sizeof(XGL_DESCRIPTOR_SET_MAPPING));
- stageInfo->shader.pDescriptorSetMapping->descriptorCount = 0;
stageInfo->shader.linkConstBufferCount = 0;
stageInfo->shader.pLinkConstBufferInfo = XGL_NULL_HANDLE;
- stageInfo->shader.dynamicBufferViewMapping.slotObjectType = XGL_SLOT_UNUSED;
- stageInfo->shader.dynamicBufferViewMapping.shaderEntityIndex = 0;
- stageInfo->shader.pDescriptorSetMapping->descriptorCount = descriptorSet->GetTotalSlots();
- if (stageInfo->shader.pDescriptorSetMapping->descriptorCount)
- {
- vector<int> allSlots;
- vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> allTypes;
- vector<void *> allObjs;
-
- allSlots.reserve(m_bufferSlots.size() + m_imageSlots.size() + m_samplerSlots.size());
- allTypes.reserve(m_bufferTypes.size() + m_imageTypes.size() + m_samplerTypes.size());
- allObjs.reserve(m_bufferObjs.size() + m_imageObjs.size() + m_samplerObjs.size());
-
- if (m_bufferSlots.size())
- {
- allSlots.insert(allSlots.end(), m_bufferSlots.begin(), m_bufferSlots.end());
- allTypes.insert(allTypes.end(), m_bufferTypes.begin(), m_bufferTypes.end());
- allObjs.insert(allObjs.end(), m_bufferObjs.begin(), m_bufferObjs.end());
- }
- if (m_imageSlots.size())
- {
- allSlots.insert(allSlots.end(), m_imageSlots.begin(), m_imageSlots.end());
- allTypes.insert(allTypes.end(), m_imageTypes.begin(), m_imageTypes.end());
- allObjs.insert(allObjs.end(), m_imageObjs.begin(), m_imageObjs.end());
- }
- if (m_samplerSlots.size())
- {
- allSlots.insert(allSlots.end(), m_samplerSlots.begin(), m_samplerSlots.end());
- allTypes.insert(allTypes.end(), m_samplerTypes.begin(), m_samplerTypes.end());
- allObjs.insert(allObjs.end(), m_samplerObjs.begin(), m_samplerObjs.end());
- }
-
- slotInfo = descriptorSet->GetSlotInfo(allSlots, allTypes, allObjs);
- stageInfo->shader.pDescriptorSetMapping[0].pDescriptorInfo = (const XGL_DESCRIPTOR_SLOT_INFO*) slotInfo;
- }
return stageInfo;
}
-void XglShaderObj::BindShaderEntitySlotToBuffer(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglConstantBufferObj *constantBuffer)
-{
- m_bufferSlots.push_back(slot);
- m_bufferTypes.push_back(type);
- m_bufferObjs.push_back(&constantBuffer->m_bufferViewInfo);
-
-}
-
-void XglShaderObj::BindShaderEntitySlotToImage(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglTextureObj *texture)
-{
- m_imageSlots.push_back(slot);
- m_imageTypes.push_back(type);
- m_imageObjs.push_back(&texture->m_textureViewInfo);
-
-}
-
-void XglShaderObj::BindShaderEntitySlotToSampler(int slot, XglSamplerObj *sampler)
-{
- m_samplerSlots.push_back(slot);
- m_samplerTypes.push_back(XGL_SLOT_SHADER_SAMPLER);
- m_samplerObjs.push_back(sampler);
-
-}
-
XglShaderObj::XglShaderObj(XglDevice *device, const char * shader_code, XGL_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework)
{
XGL_RESULT err = XGL_SUCCESS;
for (int i=0; i<m_shaderObjs.size(); i++)
{
- shaderCreateInfo = m_shaderObjs[i]->GetStageCreateInfo(descriptorSet);
+ shaderCreateInfo = m_shaderObjs[i]->GetStageCreateInfo();
shaderCreateInfo->pNext = head_ptr;
head_ptr = shaderCreateInfo;
}
info.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
info.pNext = head_ptr;
info.flags = 0;
+ info.lastSetLayout = descriptorSet->GetLayout();
m_cb_state.attachmentCount = m_colorAttachments.size();
m_cb_state.pAttachments = &m_colorAttachments[0];
for (int i=0; i<m_shaderObjs.size(); i++)
{
- shaderCreateInfo = m_shaderObjs[i]->GetStageCreateInfo(descriptorSet);
+ shaderCreateInfo = m_shaderObjs[i]->GetStageCreateInfo();
shaderCreateInfo->pNext = head_ptr;
head_ptr = shaderCreateInfo;
}
info.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
info.pNext = head_ptr;
info.flags = 0;
+ info.lastSetLayout = descriptorSet->GetLayout();
init(*m_device, info);
void XglCommandBufferObj::BindDescriptorSet(XGL_DESCRIPTOR_SET descriptorSet)
{
// bind pipeline, vertex buffer (descriptor set) and WVP (dynamic buffer view)
- xglCmdBindDescriptorSet(obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, descriptorSet, 0 );
+ xglCmdBindDescriptorSet(obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS, descriptorSet, NULL );
}
void XglCommandBufferObj::BindIndexBuffer(XglIndexBufferObj *indexBuffer, XGL_UINT offset)
{
class XglIndexBufferObj;
class XglConstantBufferObj;
-class XglCommandBufferObj : xgl_testing::CmdBuffer
+class XglCommandBufferObj : public xgl_testing::CmdBuffer
{
public:
XglCommandBufferObj(XglDevice *device);
};
-class XglDescriptorSetObj : public xgl_testing::DescriptorSet
+class XglDescriptorSetObj : public xgl_testing::DescriptorRegion
{
public:
XglDescriptorSetObj(XglDevice *device);
- void AttachBufferView(XglConstantBufferObj* constantBuffer);
- void AttachSampler( XglSamplerObj* sampler);
- void AttachImageView( XglTextureObj* texture);
- void BindCommandBuffer(XGL_CMD_BUFFER commandBuffer);
- void CreateXGLDescriptorSet();
+ ~XglDescriptorSetObj();
+
+ int AppendDummy();
+ int AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj* constantBuffer);
+ int AppendSamplerTexture(XglSamplerObj* sampler, XglTextureObj* texture);
+ void CreateXGLDescriptorSet(XglCommandBufferObj *cmdBuffer);
+
XGL_DESCRIPTOR_SET GetDescriptorSetHandle();
- int GetTotalSlots();
- XGL_DESCRIPTOR_SLOT_INFO * GetSlotInfo(vector<int>slots, vector<XGL_DESCRIPTOR_SET_SLOT_TYPE>types, vector<void*>objs );
+ XGL_DESCRIPTOR_SET_LAYOUT GetLayout();
protected:
XglDevice *m_device;
- XGL_DESCRIPTOR_SLOT_INFO *m_slotInfo;
+ vector<XGL_DESCRIPTOR_TYPE_COUNT> m_type_counts;
int m_nextSlot;
- vector<int> m_bufferSlots;
- vector<XGL_BUFFER_VIEW_ATTACH_INFO*> m_bufferViews;
- vector<int> m_samplerSlots;
- vector<XglSamplerObj*> m_samplers;
- vector<int> m_imageSlots;
- vector<XGL_IMAGE_VIEW_ATTACH_INFO*> m_imageViews;
+
+ vector<const XGL_BUFFER_VIEW_ATTACH_INFO *> m_bufferInfo;
+ vector<XGL_UPDATE_BUFFERS> m_updateBuffers;
+
+ vector<XGL_SAMPLER_IMAGE_VIEW_INFO> m_samplerTextureInfo;
+ vector<XGL_UPDATE_SAMPLER_TEXTURES> m_updateSamplerTextures;
+
+ xgl_testing::DescriptorSetLayout m_layout;
+ xgl_testing::DescriptorSet *m_set;
};
{
public:
XglShaderObj(XglDevice *device, const char * shaderText, XGL_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework);
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* GetStageCreateInfo(XglDescriptorSetObj *descriptorSet);
- void BindShaderEntitySlotToBuffer(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglConstantBufferObj *constantBuffer);
- void BindShaderEntitySlotToImage(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglTextureObj *texture);
- void BindShaderEntitySlotToSampler(int slot, XglSamplerObj *sampler);
+ XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* GetStageCreateInfo();
protected:
XGL_PIPELINE_SHADER_STAGE_CREATE_INFO stage_info;
XGL_PIPELINE_SHADER_STAGE m_stage;
XglDevice *m_device;
- vector<int> m_bufferSlots;
- vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_bufferTypes;
- vector<XGL_BUFFER_VIEW_ATTACH_INFO*> m_bufferObjs;
- vector<int> m_samplerSlots;
- vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_samplerTypes;
- vector<XglSamplerObj*> m_samplerObjs;
- vector<int> m_imageSlots;
- vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_imageTypes;
- vector<XGL_IMAGE_VIEW_ATTACH_INFO*> m_imageObjs;
};
return err;
}
+void Device::begin_descriptor_region_update(XGL_DESCRIPTOR_UPDATE_MODE mode)
+{
+ EXPECT(xglBeginDescriptorRegionUpdate(obj(), mode) == XGL_SUCCESS);
+}
+
+void Device::end_descriptor_region_update(CmdBuffer &cmd)
+{
+ EXPECT(xglEndDescriptorRegionUpdate(obj(), cmd.obj()) == XGL_SUCCESS);
+}
+
void Queue::submit(const std::vector<const CmdBuffer *> &cmds, const std::vector<XGL_MEMORY_REF> &mem_refs, Fence &fence)
{
const std::vector<XGL_CMD_BUFFER> cmd_objs = make_objects<XGL_CMD_BUFFER>(cmds);
alloc_memory(dev);
}
-void DescriptorSet::init(const Device &dev, const XGL_DESCRIPTOR_SET_CREATE_INFO &info)
+void DescriptorSetLayout::init(const Device &dev, XGL_FLAGS stage_mask,
+ const std::vector<uint32_t> &bind_points,
+ const DescriptorSetLayout &prior_layout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO &info)
+{
+ DERIVED_OBJECT_INIT(xglCreateDescriptorSetLayout, dev.obj(), stage_mask,
+ &bind_points[0], prior_layout.obj(), &info);
+ alloc_memory(dev);
+}
+
+void DescriptorSetLayout::init(const Device &dev, uint32_t bind_point,
+ const DescriptorSetLayout &prior_layout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO &info)
+{
+ init(dev, XGL_SHADER_STAGE_FLAGS_ALL, std::vector<uint32_t>(1, bind_point), prior_layout, info);
+}
+
+void DescriptorRegion::init(const Device &dev, XGL_DESCRIPTOR_REGION_USAGE usage,
+ uint32_t max_sets, const XGL_DESCRIPTOR_REGION_CREATE_INFO &info)
{
- DERIVED_OBJECT_INIT(xglCreateDescriptorSet, dev.obj(), &info);
- info_ = info;
+ DERIVED_OBJECT_INIT(xglCreateDescriptorRegion, dev.obj(), usage, max_sets, &info);
+ alloc_memory(dev);
+}
+
+void DescriptorRegion::clear()
+{
+ EXPECT(xglClearDescriptorRegion(obj()) == XGL_SUCCESS);
+}
+
+std::vector<DescriptorSet *> DescriptorRegion::alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const std::vector<const DescriptorSetLayout *> &layouts)
+{
+ const std::vector<XGL_DESCRIPTOR_SET_LAYOUT> layout_objs = make_objects<XGL_DESCRIPTOR_SET_LAYOUT>(layouts);
+
+ std::vector<XGL_DESCRIPTOR_SET> set_objs;
+ set_objs.resize(layout_objs.size());
+
+ uint32_t set_count;
+ XGL_RESULT err = xglAllocDescriptorSets(obj(), usage, layout_objs.size(), &layout_objs[0], &set_objs[0], &set_count);
+ if (err == XGL_SUCCESS)
+ EXPECT(set_count == set_objs.size());
+ set_objs.resize(set_count);
+
+ std::vector<DescriptorSet *> sets;
+ sets.reserve(set_count);
+ for (std::vector<XGL_DESCRIPTOR_SET>::const_iterator it = set_objs.begin(); it != set_objs.end(); it++) {
+ // do descriptor sets need memories bound?
+ sets.push_back(new DescriptorSet(*it));
+ }
+
+ return sets;
}
-void DescriptorSet::attach(uint32_t start_slot, const std::vector<const Sampler *> &samplers)
+std::vector<DescriptorSet *> DescriptorRegion::alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout, uint32_t count)
{
- const std::vector<XGL_SAMPLER> sampler_objs = make_objects<XGL_SAMPLER>(samplers);
- xglAttachSamplerDescriptors(obj(), start_slot, sampler_objs.size(), &sampler_objs[0]);
+ return alloc_sets(usage, std::vector<const DescriptorSetLayout *>(count, &layout));
}
-void DescriptorSet::attach(uint32_t start_slot, const std::vector<XGL_IMAGE_VIEW_ATTACH_INFO> &img_views)
+DescriptorSet *DescriptorRegion::alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout)
{
- xglAttachImageViewDescriptors(obj(), start_slot, img_views.size(), &img_views[0]);
+ std::vector<DescriptorSet *> set = alloc_sets(usage, layout, 1);
+ return (set.empty()) ? NULL : set[0];
}
-void DescriptorSet::attach(uint32_t start_slot, const std::vector<XGL_BUFFER_VIEW_ATTACH_INFO> &buf_views)
+void DescriptorRegion::clear_sets(const std::vector<DescriptorSet *> &sets)
{
- xglAttachBufferViewDescriptors(obj(), start_slot, buf_views.size(), &buf_views[0]);
+ const std::vector<XGL_DESCRIPTOR_SET> set_objs = make_objects<XGL_DESCRIPTOR_SET>(sets);
+ xglClearDescriptorSets(obj(), set_objs.size(), &set_objs[0]);
}
-void DescriptorSet::attach(uint32_t start_slot, const std::vector<XGL_DESCRIPTOR_SET_ATTACH_INFO> &sets)
+void DescriptorSet::update(const void *update_chain)
{
- xglAttachNestedDescriptors(obj(), start_slot, sets.size(), &sets[0]);
+ xglUpdateDescriptors(obj(), update_chain);
}
void DynamicVpStateObject::init(const Device &dev, const XGL_DYNAMIC_VP_STATE_CREATE_INFO &info)
class Pipeline;
class PipelineDelta;
class Sampler;
+class DescriptorSetLayout;
+class DescriptorSetRegion;
class DescriptorSet;
class DynamicVpStateObject;
class DynamicRsStateObject;
XGL_RESULT wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout);
XGL_RESULT wait(const Fence &fence) { return wait(std::vector<const Fence *>(1, &fence), true, (uint64_t) -1); }
+ // xglBeginDescriptorRegionUpdate()
+ // xglEndDescriptorRegionUpdate()
+ void begin_descriptor_region_update(XGL_DESCRIPTOR_UPDATE_MODE mode);
+ void end_descriptor_region_update(CmdBuffer &cmd);
+
private:
enum QueueIndex {
GRAPHICS,
void init(const Device &dev, const XGL_SAMPLER_CREATE_INFO &info);
};
-class DescriptorSet : public DerivedObject<XGL_DESCRIPTOR_SET, Object> {
+class DescriptorSetLayout : public DerivedObject<XGL_DESCRIPTOR_SET_LAYOUT, Object> {
public:
- // xglCreateDescriptorSet()
- void init(const Device &dev, const XGL_DESCRIPTOR_SET_CREATE_INFO &info);
+ // xglCreateDescriptorSetLayout()
+ void init(const Device &dev, XGL_FLAGS stage_mask,
+ const std::vector<uint32_t> &bind_points,
+ const DescriptorSetLayout &prior_layout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO &info);
+ void init(const Device &dev, uint32_t bind_point,
+ const DescriptorSetLayout &prior_layout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO &info);
+ void init(const Device &dev, uint32_t bind_point,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO &info) { init(dev, bind_point, DescriptorSetLayout(), info); }
+};
- // xglBeginDescriptorSetUpdate()
- // xglEndDescriptorSetUpdate()
- void begin() { xglBeginDescriptorSetUpdate(obj()); }
- void end() { xglEndDescriptorSetUpdate(obj()); }
+class DescriptorRegion : public DerivedObject<XGL_DESCRIPTOR_REGION, Object> {
+public:
+ // xglCreateDescriptorRegion()
+ void init(const Device &dev, XGL_DESCRIPTOR_REGION_USAGE usage,
+ uint32_t max_sets, const XGL_DESCRIPTOR_REGION_CREATE_INFO &info);
- // xglAttachSamplerDescriptors()
- void attach(uint32_t start_slot, const std::vector<const Sampler *> &samplers);
- void attach(uint32_t start_slot, const Sampler &sampler)
- {
- attach(start_slot, std::vector<const Sampler *>(1, &sampler));
- }
+ // xglClearDescriptorRegion()
+ void clear();
- // xglAttachImageViewDescriptors()
- void attach(uint32_t start_slot, const std::vector<XGL_IMAGE_VIEW_ATTACH_INFO> &img_views);
- void attach(uint32_t start_slot, const XGL_IMAGE_VIEW_ATTACH_INFO &view)
- {
- attach(start_slot, std::vector<XGL_IMAGE_VIEW_ATTACH_INFO>(1, view));
- }
+ // xglAllocDescriptorSets()
+ std::vector<DescriptorSet *> alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const std::vector<const DescriptorSetLayout *> &layouts);
+ std::vector<DescriptorSet *> alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout, uint32_t count);
+ DescriptorSet *alloc_sets(XGL_DESCRIPTOR_SET_USAGE usage, const DescriptorSetLayout &layout);
- // xglAttachBufferViewDescriptors()
- void attach(uint32_t start_slot, const std::vector<XGL_BUFFER_VIEW_ATTACH_INFO> &buf_views);
- void attach(uint32_t start_slot, const XGL_BUFFER_VIEW_ATTACH_INFO &view)
- {
- attach(start_slot, std::vector<XGL_BUFFER_VIEW_ATTACH_INFO>(1, view));
- }
+ // xglClearDescriptorSets()
+ void clear_sets(const std::vector<DescriptorSet *> &sets);
+ void clear_sets(DescriptorSet &set) { clear_sets(std::vector<DescriptorSet *>(1, &set)); }
+};
- // xglAttachNestedDescriptors()
- void attach(uint32_t start_slot, const std::vector<XGL_DESCRIPTOR_SET_ATTACH_INFO> &sets);
- void attach(uint32_t start_slot, const XGL_DESCRIPTOR_SET_ATTACH_INFO &set)
- {
- attach(start_slot, std::vector<XGL_DESCRIPTOR_SET_ATTACH_INFO>(1, set));
- }
+class DescriptorSet : public DerivedObject<XGL_DESCRIPTOR_SET, Object> {
+public:
+ explicit DescriptorSet(XGL_DESCRIPTOR_SET set) : DerivedObject(set) {}
- // xglClearDescriptorSetSlots()
- void clear(uint32_t start_slot, uint32_t count) { xglClearDescriptorSetSlots(obj(), start_slot, count); }
- void clear() { clear(0, info_.slots); }
+ // xglUpdateDescriptors()
+ void update(const void *update_chain);
- static XGL_DESCRIPTOR_SET_CREATE_INFO create_info(uint32_t slot_count)
- {
- XGL_DESCRIPTOR_SET_CREATE_INFO info = {};
- info.sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO;
- info.slots = slot_count;
- return info;
- }
+ static XGL_UPDATE_SAMPLERS update(uint32_t index, uint32_t count, const XGL_SAMPLER *samplers);
+ static XGL_UPDATE_SAMPLERS update(uint32_t index, const std::vector<XGL_SAMPLER> &samplers);
-private:
- XGL_DESCRIPTOR_SET_CREATE_INFO info_;
+ static XGL_UPDATE_SAMPLER_TEXTURES update(uint32_t index, uint32_t count, const XGL_SAMPLER_IMAGE_VIEW_INFO *textures);
+ static XGL_UPDATE_SAMPLER_TEXTURES update(uint32_t index, const std::vector<XGL_SAMPLER_IMAGE_VIEW_INFO> &textures);
+
+ static XGL_UPDATE_IMAGES update(XGL_DESCRIPTOR_TYPE type, uint32_t index, uint32_t count, const XGL_IMAGE_VIEW_ATTACH_INFO * const *views);
+ static XGL_UPDATE_IMAGES update(XGL_DESCRIPTOR_TYPE type, uint32_t index, const std::vector<const XGL_IMAGE_VIEW_ATTACH_INFO *> &views);
+
+ static XGL_UPDATE_BUFFERS update(XGL_DESCRIPTOR_TYPE type, uint32_t index, uint32_t count, const XGL_BUFFER_VIEW_ATTACH_INFO * const *views);
+ static XGL_UPDATE_BUFFERS update(XGL_DESCRIPTOR_TYPE type, uint32_t index, const std::vector<const XGL_BUFFER_VIEW_ATTACH_INFO *> &views);
+
+ static XGL_UPDATE_AS_COPY update(XGL_DESCRIPTOR_TYPE type, uint32_t index, uint32_t count, const DescriptorSet &set);
+
+ static XGL_BUFFER_VIEW_ATTACH_INFO attach_info(const BufferView &view);
+ static XGL_IMAGE_VIEW_ATTACH_INFO attach_info(const ImageView &view, XGL_IMAGE_LAYOUT layout);
};
class DynamicVpStateObject : public DerivedObject<XGL_DYNAMIC_VP_STATE_OBJECT, DynamicStateObject> {
return info;
}
+inline XGL_BUFFER_VIEW_ATTACH_INFO DescriptorSet::attach_info(const BufferView &view)
+{
+ XGL_BUFFER_VIEW_ATTACH_INFO info = {};
+ info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
+ info.view = view.obj();
+ return info;
+}
+
+inline XGL_IMAGE_VIEW_ATTACH_INFO DescriptorSet::attach_info(const ImageView &view, XGL_IMAGE_LAYOUT layout)
+{
+ XGL_IMAGE_VIEW_ATTACH_INFO info = {};
+ info.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
+ info.view = view.obj();
+ info.layout = layout;
+ return info;
+}
+
+inline XGL_UPDATE_SAMPLERS DescriptorSet::update(uint32_t index, uint32_t count, const XGL_SAMPLER *samplers)
+{
+ XGL_UPDATE_SAMPLERS info = {};
+ info.sType = XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS;
+ info.index = index;
+ info.count = count;
+ info.pSamplers = samplers;
+ return info;
+}
+
+inline XGL_UPDATE_SAMPLERS DescriptorSet::update(uint32_t index, const std::vector<XGL_SAMPLER> &samplers)
+{
+ return update(index, samplers.size(), &samplers[0]);
+}
+
+inline XGL_UPDATE_SAMPLER_TEXTURES DescriptorSet::update(uint32_t index, uint32_t count, const XGL_SAMPLER_IMAGE_VIEW_INFO *textures)
+{
+ XGL_UPDATE_SAMPLER_TEXTURES info = {};
+ info.sType = XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES;
+ info.index = index;
+ info.count = count;
+ info.pSamplerImageViews = textures;
+ return info;
+}
+
+inline XGL_UPDATE_SAMPLER_TEXTURES DescriptorSet::update(uint32_t index, const std::vector<XGL_SAMPLER_IMAGE_VIEW_INFO> &textures)
+{
+ return update(index, textures.size(), &textures[0]);
+}
+
+inline XGL_UPDATE_IMAGES DescriptorSet::update(XGL_DESCRIPTOR_TYPE type, uint32_t index, uint32_t count,
+ const XGL_IMAGE_VIEW_ATTACH_INFO * const *views)
+{
+ XGL_UPDATE_IMAGES info = {};
+ info.sType = XGL_STRUCTURE_TYPE_UPDATE_IMAGES;
+ info.descriptorType = type;
+ info.index = index;
+ info.count = count;
+ info.pImageViews = views;
+ return info;
+}
+
+inline XGL_UPDATE_IMAGES DescriptorSet::update(XGL_DESCRIPTOR_TYPE type, uint32_t index,
+ const std::vector<const XGL_IMAGE_VIEW_ATTACH_INFO *> &views)
+{
+ return update(type, index, views.size(), &views[0]);
+}
+
+inline XGL_UPDATE_BUFFERS DescriptorSet::update(XGL_DESCRIPTOR_TYPE type, uint32_t index, uint32_t count,
+ const XGL_BUFFER_VIEW_ATTACH_INFO * const *views)
+{
+ XGL_UPDATE_BUFFERS info = {};
+ info.sType = XGL_STRUCTURE_TYPE_UPDATE_BUFFERS;
+ info.descriptorType = type;
+ info.index = index;
+ info.count = count;
+ info.pBufferViews = views;
+ return info;
+}
+
+inline XGL_UPDATE_BUFFERS DescriptorSet::update(XGL_DESCRIPTOR_TYPE type, uint32_t index,
+ const std::vector<const XGL_BUFFER_VIEW_ATTACH_INFO *> &views)
+{
+ return update(type, index, views.size(), &views[0]);
+}
+
+inline XGL_UPDATE_AS_COPY DescriptorSet::update(XGL_DESCRIPTOR_TYPE type, uint32_t index, uint32_t count, const DescriptorSet &set)
+{
+ XGL_UPDATE_AS_COPY info = {};
+ info.sType = XGL_STRUCTURE_TYPE_UPDATE_AS_COPY;
+ info.descriptorType = type;
+ info.descriptorIndex = index; // whose index?
+ info.count = count;
+ info.descriptorSet = set.obj();
+ return info;
+}
+
inline XGL_CMD_BUFFER_CREATE_INFO CmdBuffer::create_info(XGL_QUEUE_TYPE type)
{
XGL_CMD_BUFFER_CREATE_INFO info = {};
" return res;\n"
"}"
% (qual, decl, proto.params[0].name, stmt, obj_write_stmt, proto.params[-1].name))
+ elif proto.name == "AllocDescriptorSets":
+ funcs.append("%s%s\n"
+ "{\n"
+ " const XGL_LAYER_DISPATCH_TABLE **disp =\n"
+ " (const XGL_LAYER_DISPATCH_TABLE **) %s;\n"
+ " uint32_t i;\n"
+ " XGL_RESULT res = %s;\n"
+ " for (i = 0; i < *%s; i++)\n"
+ " *(const XGL_LAYER_DISPATCH_TABLE **) (%s[i]) = *disp;\n"
+ " return res;\n"
+ "}" % (qual, decl, proto.params[0].name, stmt, proto.params[-1].name, proto.params[-2].name))
elif proto.name == "GetMultiGpuCompatibility":
funcs.append("%s%s\n"
"{\n"
"XGL_PIPELINE_DELTA",
"XGL_SAMPLER",
"XGL_DESCRIPTOR_SET",
+ "XGL_DESCRIPTOR_SET_LAYOUT",
+ "XGL_DESCRIPTOR_REGION",
"XGL_DYNAMIC_STATE_OBJECT",
"XGL_DYNAMIC_VP_STATE_OBJECT",
"XGL_DYNAMIC_RS_STATE_OBJECT",
Param("const XGL_SAMPLER_CREATE_INFO*", "pCreateInfo"),
Param("XGL_SAMPLER*", "pSampler")]),
- Proto("XGL_RESULT", "CreateDescriptorSet",
+ Proto("XGL_RESULT", "CreateDescriptorSetLayout",
[Param("XGL_DEVICE", "device"),
- Param("const XGL_DESCRIPTOR_SET_CREATE_INFO*", "pCreateInfo"),
- Param("XGL_DESCRIPTOR_SET*", "pDescriptorSet")]),
+ Param("XGL_FLAGS", "stageFlags"),
+ Param("const XGL_UINT*", "pSetBindPoints"),
+ Param("XGL_DESCRIPTOR_SET_LAYOUT", "priorSetLayout"),
+ Param("const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*", "pSetLayoutInfoList"),
+ Param("XGL_DESCRIPTOR_SET_LAYOUT*", "pSetLayout")]),
- Proto("XGL_VOID", "BeginDescriptorSetUpdate",
- [Param("XGL_DESCRIPTOR_SET", "descriptorSet")]),
+ Proto("XGL_RESULT", "BeginDescriptorRegionUpdate",
+ [Param("XGL_DEVICE", "device"),
+ Param("XGL_DESCRIPTOR_UPDATE_MODE", "updateMode")]),
- Proto("XGL_VOID", "EndDescriptorSetUpdate",
- [Param("XGL_DESCRIPTOR_SET", "descriptorSet")]),
+ Proto("XGL_RESULT", "EndDescriptorRegionUpdate",
+ [Param("XGL_DEVICE", "device"),
+ Param("XGL_CMD_BUFFER", "cmd")]),
- Proto("XGL_VOID", "AttachSamplerDescriptors",
- [Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
- Param("XGL_UINT", "startSlot"),
- Param("XGL_UINT", "slotCount"),
- Param("const XGL_SAMPLER*", "pSamplers")]),
+ Proto("XGL_RESULT", "CreateDescriptorRegion",
+ [Param("XGL_DEVICE", "device"),
+ Param("XGL_DESCRIPTOR_REGION_USAGE", "regionUsage"),
+ Param("XGL_UINT", "maxSets"),
+ Param("const XGL_DESCRIPTOR_REGION_CREATE_INFO*", "pCreateInfo"),
+ Param("XGL_DESCRIPTOR_REGION*", "pDescriptorRegion")]),
- Proto("XGL_VOID", "AttachImageViewDescriptors",
- [Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
- Param("XGL_UINT", "startSlot"),
- Param("XGL_UINT", "slotCount"),
- Param("const XGL_IMAGE_VIEW_ATTACH_INFO*", "pImageViews")]),
+ Proto("XGL_RESULT", "ClearDescriptorRegion",
+ [Param("XGL_DESCRIPTOR_REGION", "descriptorRegion")]),
- Proto("XGL_VOID", "AttachBufferViewDescriptors",
- [Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
- Param("XGL_UINT", "startSlot"),
- Param("XGL_UINT", "slotCount"),
- Param("const XGL_BUFFER_VIEW_ATTACH_INFO*", "pBufferViews")]),
+ Proto("XGL_RESULT", "AllocDescriptorSets",
+ [Param("XGL_DESCRIPTOR_REGION", "descriptorRegion"),
+ Param("XGL_DESCRIPTOR_SET_USAGE", "setUsage"),
+ Param("XGL_UINT", "count"),
+ Param("const XGL_DESCRIPTOR_SET_LAYOUT*", "pSetLayouts"),
+ Param("XGL_DESCRIPTOR_SET*", "pDescriptorSets"),
+ Param("XGL_UINT*", "pCount")]),
- Proto("XGL_VOID", "AttachNestedDescriptors",
- [Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
- Param("XGL_UINT", "startSlot"),
- Param("XGL_UINT", "slotCount"),
- Param("const XGL_DESCRIPTOR_SET_ATTACH_INFO*", "pNestedDescriptorSets")]),
+ Proto("XGL_VOID", "ClearDescriptorSets",
+ [Param("XGL_DESCRIPTOR_REGION", "descriptorRegion"),
+ Param("XGL_UINT", "count"),
+ Param("const XGL_DESCRIPTOR_SET*", "pDescriptorSets")]),
- Proto("XGL_VOID", "ClearDescriptorSetSlots",
+ Proto("XGL_VOID", "UpdateDescriptors",
[Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
- Param("XGL_UINT", "startSlot"),
- Param("XGL_UINT", "slotCount")]),
+ Param("const XGL_VOID*", "pUpdateChain")]),
Proto("XGL_RESULT", "CreateDynamicViewportState",
[Param("XGL_DEVICE", "device"),
Proto("XGL_VOID", "CmdBindDescriptorSet",
[Param("XGL_CMD_BUFFER", "cmdBuffer"),
Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
- Param("XGL_UINT", "index"),
Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
- Param("XGL_UINT", "slotOffset")]),
-
- Proto("XGL_VOID", "CmdBindDynamicBufferView",
- [Param("XGL_CMD_BUFFER", "cmdBuffer"),
- Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
- Param("const XGL_BUFFER_VIEW_ATTACH_INFO*", "pBufferView")]),
+ Param("const XGL_UINT*", "pUserData")]),
Proto("XGL_VOID", "CmdBindVertexBuffer",
[Param("XGL_CMD_BUFFER", "cmdBuffer"),
projects / platform / upstream / Vulkan-LoaderAndValidationLayers.git / commitdiff