All of the codegen for layers is now working well enough that the generated layers will compile.
Lots of updates required to DrawState and MemTracker layers so just commenting them out the build initially.
Conflicts:
layers/draw_state.c
layers/multi.cpp
xgl-layer-generate.py
xgl.py
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 441133a..a874a98 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -40,6 +40,6 @@
add_subdirectory(loader)
add_subdirectory(icd)
add_subdirectory(tests)
-# add_subdirectory(layers)
+add_subdirectory(layers)
add_subdirectory(demos)
# add_subdirectory(tools/glave)
diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt
index 618e491..3971ce5 100644
--- a/layers/CMakeLists.txt
+++ b/layers/CMakeLists.txt
@@ -71,8 +71,8 @@
add_xgl_layer(Basic basic.cpp)
add_xgl_layer(Multi multi.cpp)
-add_xgl_layer(DrawState draw_state.c layers_config.cpp)
-add_xgl_layer(MemTracker mem_tracker.c layers_config.cpp)
+#add_xgl_layer(DrawState draw_state.c layers_config.cpp)
+#add_xgl_layer(MemTracker mem_tracker.c layers_config.cpp)
# generated
add_xgl_layer(Generic generic_layer.c)
add_xgl_layer(APIDump api_dump.c)
diff --git a/layers/draw_state.c b/layers/draw_state.c
index 47f85cd..9eed13e 100644
--- a/layers/draw_state.c
+++ b/layers/draw_state.c
@@ -122,12 +122,12 @@
return sizeof(XGL_MEMORY_OPEN_INFO);
case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
return sizeof(XGL_PEER_MEMORY_OPEN_INFO);
- case XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO:
- return sizeof(XGL_MEMORY_VIEW_ATTACH_INFO);
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+ return sizeof(XGL_BUFFER_VIEW_ATTACH_INFO);
case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
return sizeof(XGL_IMAGE_VIEW_ATTACH_INFO);
- case XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION:
- return sizeof(XGL_MEMORY_STATE_TRANSITION);
+ case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+ return sizeof(XGL_EVENT_WAIT_INFO);
case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
return sizeof(XGL_IMAGE_VIEW_CREATE_INFO);
case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
@@ -140,16 +140,16 @@
return sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO);
case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
return sizeof(XGL_SAMPLER_CREATE_INFO);
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO:
- return sizeof(XGL_DESCRIPTOR_SET_CREATE_INFO);
- case XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO:
- return sizeof(XGL_RASTER_STATE_CREATE_INFO);
- case XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO:
- return sizeof(XGL_MSAA_STATE_CREATE_INFO);
- case XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO:
- return sizeof(XGL_COLOR_BLEND_STATE_CREATE_INFO);
- case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO:
- return sizeof(XGL_DEPTH_STENCIL_STATE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+ return sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+ return sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+ return sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+ return sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+ return sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO);
case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
return sizeof(XGL_CMD_BUFFER_CREATE_INFO);
case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
@@ -166,22 +166,62 @@
return sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO);
case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
return sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO);
- case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
- return sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);
- case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:
- return sizeof(XGL_PIPELINE_DB_STATE_CREATE_INFO);
- case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
- return sizeof(XGL_PIPELINE_CB_STATE);
- case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
- return sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);
- case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
- return sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);
- case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
- return sizeof(XGL_IMAGE_CREATE_INFO);
case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
return sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ return sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+ return sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ return sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ return sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+ return sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ return sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+ return sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+ return sizeof(XGL_IMAGE_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+ return sizeof(XGL_BUFFER_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+ return sizeof(XGL_BUFFER_VIEW_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+ return sizeof(XGL_FRAMEBUFFER_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+ return sizeof(XGL_CMD_BUFFER_BEGIN_INFO);
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+ return sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO);
+ case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+ return sizeof(XGL_RENDER_PASS_CREATE_INFO);
case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
return sizeof(XGL_LAYER_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+ return sizeof(XGL_PIPELINE_BARRIER);
+ case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+ return sizeof(XGL_MEMORY_BARRIER);
+ case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+ return sizeof(XGL_BUFFER_MEMORY_BARRIER);
+ case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+ return sizeof(XGL_IMAGE_MEMORY_BARRIER);
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+ return sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO);
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ return sizeof(XGL_UPDATE_SAMPLERS);
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ return sizeof(XGL_UPDATE_SAMPLER_TEXTURES);
+ case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+ return sizeof(XGL_UPDATE_IMAGES);
+ case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ return sizeof(XGL_UPDATE_BUFFERS);
+ case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ return sizeof(XGL_UPDATE_AS_COPY);
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+ return sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO);
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+ return sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO);
default:
return 0;
}
@@ -193,15 +233,13 @@
switch (sType)
{
case XGL_STATE_BIND_VIEWPORT:
- return sizeof(XGL_VIEWPORT_STATE_CREATE_INFO);
+ return sizeof(XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO);
case XGL_STATE_BIND_RASTER:
- return sizeof(XGL_RASTER_STATE_CREATE_INFO);
+ return sizeof(XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO);
case XGL_STATE_BIND_DEPTH_STENCIL:
- return sizeof(XGL_DEPTH_STENCIL_STATE_CREATE_INFO);
+ return sizeof(XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO);
case XGL_STATE_BIND_COLOR_BLEND:
- return sizeof(XGL_COLOR_BLEND_STATE_CREATE_INFO);
- case XGL_STATE_BIND_MSAA:
- return sizeof(XGL_MSAA_STATE_CREATE_INFO);
+ return sizeof(XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO);
default:
return 0;
}
@@ -215,12 +253,13 @@
typedef struct _SHADER_DS_MAPPING {
uint32_t slotCount;
- XGL_DESCRIPTOR_SLOT_INFO* pShaderMappingSlot;
+ // TODO : Need to understand this with new binding model, changed to LAYOUT_CI for now
+ XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pShaderMappingSlot;
} SHADER_DS_MAPPING;
typedef struct _PIPELINE_LL_HEADER {
XGL_STRUCTURE_TYPE sType;
- const void* pNext;
+ const void* pNext;
} PIPELINE_LL_HEADER;
typedef struct _PIPELINE_NODE {
@@ -228,7 +267,7 @@
struct _PIPELINE_NODE *pNext;
XGL_GRAPHICS_PIPELINE_CREATE_INFO *pCreateTree; // Ptr to shadow of data in create tree
// 1st dimension of array is shader type
- SHADER_DS_MAPPING dsMapping[XGL_NUM_GRAPHICS_SHADERS][XGL_MAX_DESCRIPTOR_SETS];
+ SHADER_DS_MAPPING dsMapping[XGL_NUM_GRAPHICS_SHADERS];
// Vtx input info (if any)
uint32_t vtxBindingCount; // number of bindings
XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions;
@@ -243,7 +282,7 @@
} SAMPLER_NODE;
typedef struct _DYNAMIC_STATE_NODE {
- XGL_STATE_OBJECT stateObj;
+ XGL_DYNAMIC_STATE_OBJECT stateObj;
XGL_STATE_BIND_POINT sType; // Extra data as VIEWPORT CreateInfo doesn't have sType
PIPELINE_LL_HEADER *pCreateInfo;
struct _DYNAMIC_STATE_NODE *pNext;
@@ -262,7 +301,7 @@
static DYNAMIC_STATE_NODE* pLastBoundDynamicState[XGL_NUM_STATE_BIND_POINT] = {0};
// Viewport state create info doesn't have sType so we have to pass in BIND_POINT
-static void insertDynamicState(const XGL_STATE_OBJECT state, const PIPELINE_LL_HEADER* pCreateInfo, const XGL_STATE_BIND_POINT sType)
+static void insertDynamicState(const XGL_DYNAMIC_STATE_OBJECT state, const PIPELINE_LL_HEADER* pCreateInfo, const XGL_STATE_BIND_POINT sType)
{
pthread_mutex_lock(&globalLock);
// Insert new node at head of appropriate LL
@@ -277,7 +316,7 @@
}
// Set the last bound dynamic state of given type
// TODO : Need to track this per cmdBuffer and correlate cmdBuffer for Draw w/ last bound for that cmdBuffer?
-static void setLastBoundDynamicState(const XGL_STATE_OBJECT state, const XGL_STATE_BIND_POINT sType)
+static void setLastBoundDynamicState(const XGL_DYNAMIC_STATE_OBJECT state, const XGL_STATE_BIND_POINT sType)
{
pthread_mutex_lock(&globalLock);
DYNAMIC_STATE_NODE* pTrav = pDynamicStateHead[sType];
@@ -304,7 +343,7 @@
switch (pLastBoundDynamicState[i]->sType)
{
case XGL_STATE_BIND_VIEWPORT:
- layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pLastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", xgl_print_xgl_viewport_state_create_info((XGL_VIEWPORT_STATE_CREATE_INFO*)pLastBoundDynamicState[i]->pCreateInfo, " "));
+ layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pLastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", xgl_print_xgl_dynamic_vp_state_create_info((XGL_DYNAMIC_VP_STATE_CREATE_INFO*)pLastBoundDynamicState[i]->pCreateInfo, " "));
break;
default:
layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pLastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", dynamic_display(pLastBoundDynamicState[i]->pCreateInfo, " "));
@@ -366,11 +405,13 @@
memcpy((void*)pShadowTrav->pNext, pTrav, sTypeStructSize(pTrav->sType));
pShadowTrav = (PIPELINE_LL_HEADER*)pShadowTrav->pNext;
// For deep copy DS Mapping into shadow
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO *pShadowShaderCI = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pShadowTrav;
+ //XGL_PIPELINE_SHADER_STAGE_CREATE_INFO *pShadowShaderCI = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pShadowTrav;
// TODO : Now that we shadow whole create info, the special copies are just a convenience that can be done away with once shadow is complete and correct
// Special copy of DS Mapping info
if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pTrav->sType) {
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO *pSSCI = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pTrav;
+ //XGL_PIPELINE_SHADER_STAGE_CREATE_INFO *pSSCI = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pTrav;
+ // TODO : Fix this for new binding model
+/*
for (uint32_t i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++) {
if (pSSCI->shader.descriptorSetMapping[i].descriptorCount > MAX_SLOTS) {
char str[1024];
@@ -380,13 +421,14 @@
}
pPipeline->dsMapping[pSSCI->shader.stage][i].slotCount = pSSCI->shader.descriptorSetMapping[i].descriptorCount;
// Deep copy DS Slot array into our shortcut data structure
- pPipeline->dsMapping[pSSCI->shader.stage][i].pShaderMappingSlot = (XGL_DESCRIPTOR_SLOT_INFO*)malloc(sizeof(XGL_DESCRIPTOR_SLOT_INFO)*pPipeline->dsMapping[pSSCI->shader.stage][i].slotCount);
- memcpy(pPipeline->dsMapping[pSSCI->shader.stage][i].pShaderMappingSlot, pSSCI->shader.descriptorSetMapping[i].pDescriptorInfo, sizeof(XGL_DESCRIPTOR_SLOT_INFO)*pPipeline->dsMapping[pSSCI->shader.stage][i].slotCount);
+ pPipeline->dsMapping[pSSCI->shader.stage][i].pShaderMappingSlot = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)malloc(sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)*pPipeline->dsMapping[pSSCI->shader.stage][i].slotCount);
+ memcpy(pPipeline->dsMapping[pSSCI->shader.stage][i].pShaderMappingSlot, pSSCI->shader.descriptorSetMapping[i].pDescriptorInfo, sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)*pPipeline->dsMapping[pSSCI->shader.stage][i].slotCount);
// Deep copy into shadow tree
pShadowShaderCI->shader.descriptorSetMapping[i].descriptorCount = pSSCI->shader.descriptorSetMapping[i].descriptorCount;
- pShadowShaderCI->shader.descriptorSetMapping[i].pDescriptorInfo = (XGL_DESCRIPTOR_SLOT_INFO*)malloc(sizeof(XGL_DESCRIPTOR_SLOT_INFO)*pShadowShaderCI->shader.descriptorSetMapping[i].descriptorCount);
- memcpy((XGL_DESCRIPTOR_SLOT_INFO*)pShadowShaderCI->shader.descriptorSetMapping[i].pDescriptorInfo, pSSCI->shader.descriptorSetMapping[i].pDescriptorInfo, sizeof(XGL_DESCRIPTOR_SLOT_INFO)*pShadowShaderCI->shader.descriptorSetMapping[i].descriptorCount);
+ pShadowShaderCI->shader.descriptorSetMapping[i].pDescriptorInfo = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)malloc(sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)*pShadowShaderCI->shader.descriptorSetMapping[i].descriptorCount);
+ memcpy((XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pShadowShaderCI->shader.descriptorSetMapping[i].pDescriptorInfo, pSSCI->shader.descriptorSetMapping[i].pDescriptorInfo, sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)*pShadowShaderCI->shader.descriptorSetMapping[i].descriptorCount);
}
+*/
}
else if (XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO == pTrav->sType) {
// Special copy of Vtx info
@@ -427,11 +469,12 @@
typedef struct _DS_SLOT {
uint32_t slot;
- XGL_DESCRIPTOR_SLOT_INFO shaderSlotInfo[XGL_NUM_GRAPHICS_SHADERS];
+ // TODO : Fix this for latest binding model
+ XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO shaderSlotInfo[XGL_NUM_GRAPHICS_SHADERS];
// Only 1 of 4 possible slot mappings active
uint32_t activeMapping;
uint32_t mappingMask; // store record of different mappings used
- XGL_MEMORY_VIEW_ATTACH_INFO memView;
+ XGL_BUFFER_VIEW_ATTACH_INFO buffView;
XGL_IMAGE_VIEW_ATTACH_INFO imageView;
XGL_SAMPLER sampler;
} DS_SLOT;
@@ -448,8 +491,9 @@
// ptr to HEAD of LL of DSs
static DS_LL_HEAD *pDSHead = NULL;
// Last DS that was bound, and slotOffset for the binding
-static XGL_DESCRIPTOR_SET lastBoundDS[XGL_MAX_DESCRIPTOR_SETS] = {NULL, NULL};
-static uint32_t lastBoundSlotOffset[XGL_MAX_DESCRIPTOR_SETS] = {0, 0};
+static XGL_DESCRIPTOR_SET lastBoundDS = NULL;
+static uint32_t lastBoundSlotOffset = 0;
+
// Return DS Head ptr for specified ds or else NULL
static DS_LL_HEAD* getDS(XGL_DESCRIPTOR_SET ds)
@@ -509,7 +553,7 @@
pSlot->activeMapping = mapping;
}
// Populate pStr w/ a string noting all of the slot mappings based on mapping flag
-static char* noteSlotMapping(uint32_t mapping, char *pStr)
+static char* noteSlotMapping(uint32_t32 mapping, char *pStr)
{
if (MAPPING_MEMORY & mapping)
strcat(pStr, "\n\tMemory View previously mapped");
@@ -522,7 +566,7 @@
return pStr;
}
-static void dsSetMemMapping(XGL_DESCRIPTOR_SET descriptorSet, DS_SLOT* pSlot, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView)
+static void dsSetMemMapping(XGL_DESCRIPTOR_SET descriptorSet, DS_SLOT* pSlot, const XGL_BUFFER_VIEW_ATTACH_INFO* pMemView)
{
if (pSlot->mappingMask) {
char str[1024];
@@ -530,11 +574,11 @@
sprintf(str, "While mapping Memory View to slot %u previous Mapping(s) identified:%s", pSlot->slot, noteSlotMapping(pSlot->mappingMask, map_str));
layerCbMsg(XGL_DBG_MSG_WARNING, XGL_VALIDATION_LEVEL_0, descriptorSet, 0, DRAWSTATE_SLOT_REMAPPING, "DS", str);
}
- memcpy(&pSlot->memView, pMemView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));
+ memcpy(&pSlot->buffView, pMemView, sizeof(XGL_BUFFER_VIEW_ATTACH_INFO));
dsSetMapping(pSlot, MAPPING_MEMORY);
}
-static bool32_t dsMemMapping(XGL_DESCRIPTOR_SET descriptorSet, uint32_t startSlot, uint32_t slotCount, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews)
+static bool32_t dsMemMapping(XGL_DESCRIPTOR_SET descriptorSet, uint32_t startSlot, uint32_t slotCount, const XGL_BUFFER_VIEW_ATTACH_INFO* pMemViews)
{
DS_LL_HEAD *pTrav = getDS(descriptorSet);
if (pTrav) {
@@ -622,7 +666,7 @@
{
const int i = 0; // hard-coding to just the first DS index for now
uint32_t skipUnusedCount = 0; // track consecutive unused slots for minimal reporting
- DS_LL_HEAD *pDS = getDS(lastBoundDS[i]);
+ DS_LL_HEAD *pDS = getDS(lastBoundDS);
if (pDS) {
fprintf(pOutFile, "subgraph DS_SLOTS\n{\nlabel=\"DS0 Slots\"\n");
// First create simple array node as central DS reference point
@@ -647,7 +691,7 @@
skipUnusedCount = 0;
}*/
sprintf(label, "MemAttachInfo Slot%u", j);
- fprintf(pOutFile, "%s", xgl_gv_print_xgl_memory_view_attach_info(&pDS->dsSlot[j].memView, label));
+ fprintf(pOutFile, "%s", xgl_gv_print_xgl_memory_view_attach_info(&pDS->dsSlot[j].buffView, label));
fprintf(pOutFile, "\"DS0_MEMORY\":slot%u -> \"%s\" [];\n", j, label);
break;
case MAPPING_IMAGE:
@@ -732,24 +776,24 @@
}
else {
// Synch Descriptor Set Mapping
- for (uint32_t i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++) {
+ //for (uint32_t i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++) {
DS_LL_HEAD *pDS;
- if (lastBoundDS[i]) {
- pDS = getDS(lastBoundDS[i]);
+ if (lastBoundDS) {
+ pDS = getDS(lastBoundDS);
if (!pDS) {
- sprintf(str, "Can't find last bound DS %p. Did you need to bind DS to index %u?", (void*)lastBoundDS[i], i);
+ sprintf(str, "Can't find last bound DS %p. Did you need to bind DS?", (void*)lastBoundDS);
layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NO_DS_BOUND, "DS", str);
}
else { // We have a good DS & Pipeline, store pipeline mappings in DS
- uint32_t slotOffset = lastBoundSlotOffset[i];
+ uint32_t slotOffset = lastBoundSlotOffset;
for (uint32_t j = 0; j < XGL_NUM_GRAPHICS_SHADERS; j++) { // j is shader selector
- if (pPipeTrav->dsMapping[j][i].slotCount > (pDS->numSlots - slotOffset)) {
- sprintf(str, "DS Mapping for shader %u has more slots (%u) than DS %p (%u) minus slotOffset (%u) (%u slots available)!", j, pPipeTrav->dsMapping[j][i].slotCount, (void*)pDS->dsID, pDS->numSlots, slotOffset, (pDS->numSlots - slotOffset));
+ if (pPipeTrav->dsMapping[j].count > (pDS->numSlots - slotOffset)) {
+ sprintf(str, "DS Mapping for shader %u has more slots (%u) than DS %p (%u) minus slotOffset (%u) (%u slots available)!", j, pPipeTrav->dsMapping[j].count, (void*)pDS->dsID, pDS->numSlots, slotOffset, (pDS->numSlots - slotOffset));
layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_DS_SLOT_NUM_MISMATCH, "DS", str);
}
else {
- for (uint32_t r = 0; r < pPipeTrav->dsMapping[j][i].slotCount; r++) {
- pDS->dsSlot[r+slotOffset].shaderSlotInfo[j] = pPipeTrav->dsMapping[j][i].pShaderMappingSlot[r];
+ for (uint32_t r = 0; r < pPipeTrav->dsMapping[j].count; r++) {
+ pDS->dsSlot[r+slotOffset].shaderSlotInfo[j] = pPipeTrav->dsMapping[j].pShaderMappingSlot[r];
}
}
}
@@ -759,18 +803,18 @@
// Verify that no shader is mapping this DS
uint32_t dsUsed = 0;
for (uint32_t j = 0; j < XGL_NUM_GRAPHICS_SHADERS; j++) { // j is shader selector
- if (pPipeTrav->dsMapping[j][i].slotCount > 0) {
+ if (pPipeTrav->dsMapping[j].count > 0) {
dsUsed = 1;
- sprintf(str, "No DS was bound to index %u, but shader type %s has slots bound to that DS.", i, string_XGL_PIPELINE_SHADER_STAGE(j));
+ sprintf(str, "No DS was bound, but shader type %s has slots bound to that DS.", string_XGL_PIPELINE_SHADER_STAGE(j));
layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NO_DS_BOUND, "DS", str);
}
}
if (0 == dsUsed) {
- sprintf(str, "No DS was bound to index %u, but no shaders are using that DS so this is not an issue.", i);
+ sprintf(str, "No DS was bound, but no shaders are using that DS so this is not an issue.");
layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str);
}
}
- }
+ //}
// Verify Vtx binding
if (MAX_BINDING != lastVtxBinding) {
if (lastVtxBinding >= pPipeTrav->vtxBindingCount) {
@@ -848,7 +892,7 @@
strcat(ds_config_str, tmp_str);
skipUnusedCount = 0;
}
- sprintf(tmp_str, "----Slot %u\n Mapped to Memory View %p:\n%s", j, (void*)&pDS->dsSlot[j].memView, xgl_print_xgl_memory_view_attach_info(&pDS->dsSlot[j].memView, " "));
+ sprintf(tmp_str, "----Slot %u\n Mapped to Memory View %p:\n%s", j, (void*)&pDS->dsSlot[j].buffView, xgl_print_xgl_memory_view_attach_info(&pDS->dsSlot[j].buffView, " "));
strcat(ds_config_str, tmp_str);
break;
case MAPPING_IMAGE:
@@ -1337,6 +1381,7 @@
pthread_mutex_unlock(&globalLock);
return result;
}
+/* TODO : Update these functions for new binding model
XGL_LAYER_EXPORT void XGLAPI xglBeginDescriptorSetUpdate(XGL_DESCRIPTOR_SET descriptorSet)
{
@@ -1457,6 +1502,7 @@
}
nextTable.ClearDescriptorSetSlots(descriptorSet, startSlot, slotCount);
}
+*/
XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateViewportState(XGL_DEVICE device, const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo, XGL_VIEWPORT_STATE_OBJECT* pState)
{
@@ -1535,7 +1581,7 @@
nextTable.CmdBindPipelineDelta(cmdBuffer, pipelineBindPoint, delta);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT state)
+XGL_LAYER_EXPORT void XGLAPI xglCmdBindStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state)
{
setLastBoundDynamicState(state, stateBindPoint);
nextTable.CmdBindStateObject(cmdBuffer, stateBindPoint, state);
@@ -1566,11 +1612,6 @@
nextTable.CmdBindDescriptorSet(cmdBuffer, pipelineBindPoint, index, descriptorSet, slotOffset);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicMemoryView(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView)
-{
- nextTable.CmdBindDynamicMemoryView(cmdBuffer, pipelineBindPoint, pMemView);
-}
-
XGL_LAYER_EXPORT void XGLAPI xglCmdBindVertexData(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, uint32_t binding)
{
lastVtxBinding = binding;
@@ -1663,16 +1704,6 @@
nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
}
-XGL_LAYER_EXPORT void XGLAPI xglCmdUpdateMemory(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData)
-{
- nextTable.CmdUpdateMemory(cmdBuffer, destMem, destOffset, dataSize, pData);
-}
-
-XGL_LAYER_EXPORT void XGLAPI xglCmdFillMemory(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data)
-{
- nextTable.CmdFillMemory(cmdBuffer, destMem, destOffset, fillSize, data);
-}
-
XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const float color[4], uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
{
nextTable.CmdClearColorImage(cmdBuffer, image, color, rangeCount, pRanges);
diff --git a/layers/multi.cpp b/layers/multi.cpp
index b8c9631..400ef5d 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -184,7 +184,7 @@
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi2BeginCommandBuffer( XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI multi2BeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo)
{
XGL_LAYER_DISPATCH_TABLE* pTable = tableMap2[cmdBuffer];
diff --git a/layers/object_track.h b/layers/object_track.h
index b6d02c3..9e9dc9b 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -35,35 +35,40 @@
OBJTRACK_OBJCOUNT_MAX_EXCEEDED, // Request for Object data in excess of max obj count
} OBJECT_TRACK_ERROR;
-
// Object type enum
typedef enum _XGL_OBJECT_TYPE
{
- XGL_OBJECT_TYPE_DEVICE,
- XGL_OBJECT_TYPE_GPU_MEMORY,
- XGL_OBJECT_TYPE_FENCE,
- XGL_OBJECT_TYPE_QUEUE_SEMAPHORE,
- XGL_OBJECT_TYPE_QUEUE,
- XGL_OBJECT_TYPE_EVENT,
- XGL_OBJECT_TYPE_QUERY_POOL,
- XGL_OBJECT_TYPE_IMAGE,
- XGL_OBJECT_TYPE_IMAGE_VIEW,
- XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW,
- XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW,
- XGL_OBJECT_TYPE_SHADER,
- XGL_OBJECT_TYPE_PIPELINE,
- XGL_OBJECT_TYPE_PIPELINE_DELTA,
XGL_OBJECT_TYPE_SAMPLER,
+ XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT,
XGL_OBJECT_TYPE_DESCRIPTOR_SET,
- XGL_OBJECT_TYPE_VIEWPORT_STATE,
- XGL_OBJECT_TYPE_RASTER_STATE,
- XGL_OBJECT_TYPE_MSAA_STATE,
- XGL_OBJECT_TYPE_COLOR_BLEND_STATE,
- XGL_OBJECT_TYPE_DEPTH_STENCIL_STATE,
- XGL_OBJECT_TYPE_CMD_BUFFER,
+ XGL_OBJECT_TYPE_DESCRIPTOR_REGION,
+ XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT,
+ XGL_OBJECT_TYPE_IMAGE_VIEW,
+ XGL_OBJECT_TYPE_QUEUE_SEMAPHORE,
+ XGL_OBJECT_TYPE_SHADER,
+ XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
+ XGL_OBJECT_TYPE_BUFFER,
+ XGL_OBJECT_TYPE_PIPELINE,
+ XGL_OBJECT_TYPE_DEVICE,
+ XGL_OBJECT_TYPE_QUERY_POOL,
+ XGL_OBJECT_TYPE_EVENT,
+ XGL_OBJECT_TYPE_QUEUE,
XGL_OBJECT_TYPE_PHYSICAL_GPU,
- XGL_OBJECT_TYPE_UNKNOWN,
+ XGL_OBJECT_TYPE_RENDER_PASS,
+ XGL_OBJECT_TYPE_FRAMEBUFFER,
+ XGL_OBJECT_TYPE_IMAGE,
+ XGL_OBJECT_TYPE_BUFFER_VIEW,
+ XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW,
+ XGL_OBJECT_TYPE_INSTANCE,
+ XGL_OBJECT_TYPE_PIPELINE_DELTA,
+ XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT,
+ XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW,
+ XGL_OBJECT_TYPE_GPU_MEMORY,
+ XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT,
+ XGL_OBJECT_TYPE_FENCE,
+ XGL_OBJECT_TYPE_CMD_BUFFER,
+ XGL_OBJECT_TYPE_UNKNOWN,
XGL_NUM_OBJECT_TYPE,
XGL_OBJECT_TYPE_ANY, // Allow global object list to be queried/retrieved
} XGL_OBJECT_TYPE;
@@ -73,50 +78,62 @@
{
case XGL_OBJECT_TYPE_DEVICE:
return "DEVICE";
- case XGL_OBJECT_TYPE_GPU_MEMORY:
- return "GPU_MEMORY";
+ case XGL_OBJECT_TYPE_PIPELINE:
+ return "PIPELINE";
case XGL_OBJECT_TYPE_FENCE:
return "FENCE";
+ case XGL_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
+ return "DESCRIPTOR_SET_LAYOUT";
+ case XGL_OBJECT_TYPE_GPU_MEMORY:
+ return "GPU_MEMORY";
case XGL_OBJECT_TYPE_QUEUE:
return "QUEUE";
+ case XGL_OBJECT_TYPE_IMAGE:
+ return "IMAGE";
+ case XGL_OBJECT_TYPE_CMD_BUFFER:
+ return "CMD_BUFFER";
case XGL_OBJECT_TYPE_QUEUE_SEMAPHORE:
return "QUEUE_SEMAPHORE";
- case XGL_OBJECT_TYPE_EVENT:
- return "EVENT";
- case XGL_OBJECT_TYPE_QUERY_POOL:
- return "QUERY_POOL";
- case XGL_OBJECT_TYPE_IMAGE:
- return "TYPE_IMAGE";
- case XGL_OBJECT_TYPE_IMAGE_VIEW:
- return "IMAGE_VIEW";
+ case XGL_OBJECT_TYPE_FRAMEBUFFER:
+ return "FRAMEBUFFER";
+ case XGL_OBJECT_TYPE_SAMPLER:
+ return "SAMPLER";
case XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW:
return "COLOR_ATTACHMENT_VIEW";
+ case XGL_OBJECT_TYPE_BUFFER_VIEW:
+ return "BUFFER_VIEW";
+ case XGL_OBJECT_TYPE_DESCRIPTOR_SET:
+ return "DESCRIPTOR_SET";
+ case XGL_OBJECT_TYPE_PHYSICAL_GPU:
+ return "PHYSICAL_GPU";
+ case XGL_OBJECT_TYPE_IMAGE_VIEW:
+ return "IMAGE_VIEW";
+ case XGL_OBJECT_TYPE_BUFFER:
+ return "BUFFER";
+ case XGL_OBJECT_TYPE_PIPELINE_DELTA:
+ return "PIPELINE_DELTA";
+ case XGL_OBJECT_TYPE_DYNAMIC_RS_STATE_OBJECT:
+ return "DYNAMIC_RS_STATE_OBJECT";
+ case XGL_OBJECT_TYPE_EVENT:
+ return "EVENT";
case XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW:
return "DEPTH_STENCIL_VIEW";
case XGL_OBJECT_TYPE_SHADER:
return "SHADER";
- case XGL_OBJECT_TYPE_PIPELINE:
- return "PIPELINE";
- case XGL_OBJECT_TYPE_PIPELINE_DELTA:
- return "PIPELINE_DELTA";
- case XGL_OBJECT_TYPE_SAMPLER:
- return "SAMPLER";
- case XGL_OBJECT_TYPE_DESCRIPTOR_SET:
- return "DESCRIPTOR_SET";
- case XGL_OBJECT_TYPE_VIEWPORT_STATE:
- return "VIEWPORT_STATE";
- case XGL_OBJECT_TYPE_RASTER_STATE:
- return "RASTER_STATE";
- case XGL_OBJECT_TYPE_MSAA_STATE:
- return "MSAA_STATE";
- case XGL_OBJECT_TYPE_COLOR_BLEND_STATE:
- return "COLOR_BLEND_STATE";
- case XGL_OBJECT_TYPE_DEPTH_STENCIL_STATE:
- return "DEPTH_STENCIL_STATE";
- case XGL_OBJECT_TYPE_CMD_BUFFER:
- return "CMD_BUFFER";
- case XGL_OBJECT_TYPE_PHYSICAL_GPU:
- return "PHYSICAL_GPU";
+ case XGL_OBJECT_TYPE_DYNAMIC_DS_STATE_OBJECT:
+ return "DYNAMIC_DS_STATE_OBJECT";
+ case XGL_OBJECT_TYPE_DYNAMIC_VP_STATE_OBJECT:
+ return "DYNAMIC_VP_STATE_OBJECT";
+ case XGL_OBJECT_TYPE_DYNAMIC_CB_STATE_OBJECT:
+ return "DYNAMIC_CB_STATE_OBJECT";
+ case XGL_OBJECT_TYPE_INSTANCE:
+ return "INSTANCE";
+ case XGL_OBJECT_TYPE_RENDER_PASS:
+ return "RENDER_PASS";
+ case XGL_OBJECT_TYPE_QUERY_POOL:
+ return "QUERY_POOL";
+ case XGL_OBJECT_TYPE_DESCRIPTOR_REGION:
+ return "DESCRIPTOR_REGION";
default:
return "UNKNOWN";
}
diff --git a/xgl-layer-generate.py b/xgl-layer-generate.py
index ae95238..77622d1 100755
--- a/xgl-layer-generate.py
+++ b/xgl-layer-generate.py
@@ -97,27 +97,27 @@
# Return set of printf '%' qualifier and input to that qualifier
def _get_printf_params(self, xgl_type, name, output_param, cpp=False):
# TODO : Need ENUM and STRUCT checks here
- if "_TYPE" in xgl_type: # TODO : This should be generic ENUM check
+ if xgl_helper.is_type(xgl_type, 'enum'):#"_TYPE" in xgl_type: # TODO : This should be generic ENUM check
return ("%s", "string_%s(%s)" % (xgl_type.strip('const ').strip('*'), name))
if "char*" == xgl_type:
return ("%s", name)
- if "UINT64" in xgl_type:
+ if "uint64" in xgl_type:
if '*' in xgl_type:
return ("%lu", "*%s" % name)
return ("%lu", name)
- if "SIZE" in xgl_type:
+ if "size" in xgl_type:
if '*' in xgl_type:
return ("%zu", "*%s" % name)
return ("%zu", name)
- if "FLOAT" in xgl_type:
+ if "float" in xgl_type:
if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
if cpp:
return ("[%i, %i, %i, %i]", '"[" << %s[0] << "," << %s[1] << "," << %s[2] << "," << %s[3] << "]"' % (name, name, name, name))
return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
return ("%f", name)
- if "BOOL" in xgl_type or 'xcb_randr_crtc_t' in xgl_type:
+ if "bool" in xgl_type or 'xcb_randr_crtc_t' in xgl_type:
return ("%u", name)
- if True in [t in xgl_type for t in ["INT", "FLAGS", "MASK", "xcb_window_t"]]:
+ if True in [t in xgl_type for t in ["int", "FLAGS", "MASK", "xcb_window_t"]]:
if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
if cpp:
return ("[%i, %i, %i, %i]", "%s[0] << %s[1] << %s[2] << %s[3]" % (name, name, name, name))
@@ -325,14 +325,15 @@
log_func += '%s = " << %s << ", ' % (p.name, pfi)
#print_vals += ', %s' % (pfi)
# TODO : Just want this to be simple check for params of STRUCT type
- if "pCreateInfo" in p.name or ('const' in p.ty and '*' in p.ty and False not in [tmp_ty not in p.ty for tmp_ty in ['char', 'void', 'XGL_CMD_BUFFER', 'XGL_QUEUE_SEMAPHORE', 'XGL_FENCE', 'XGL_SAMPLER', 'uint32_t']]):
+ #if "pCreateInfo" in p.name or ('const' in p.ty and '*' in p.ty and False not in [tmp_ty not in p.ty for tmp_ty in ['char', 'void', 'int', 'XGL_CMD_BUFFER', 'XGL_QUEUE_SEMAPHORE', 'XGL_FENCE', 'XGL_SAMPLER']]):
+ if xgl_helper.is_type(p.ty.strip('const').strip('*'), 'struct'):
if 'Wsi' not in proto.name:
cis_param_index.append(pindex)
pindex += 1
log_func = log_func.strip(', ')
if proto.ret != "void":
- log_func += ') = " << string_XGL_RESULT(result) << "\\n"'
- #print_vals += ', string_XGL_RESULT(result)'
+ log_func += ') = " << string_XGL_RESULT((XGL_RESULT)result) << "\\n"'
+ #print_vals += ', string_XGL_RESULT_CODE(result)'
else:
log_func += ')\\n"'
log_func += ';'
@@ -439,8 +440,7 @@
# Catch array inputs that are bound by a "Count" param
if prev_count_name != '' and (prev_count_name.strip('Count')[1:] in p.name or 'slotCount' == prev_count_name):
sp_param_dict[pindex] = prev_count_name
- # 'format' gets special treatment as a small struct that we print inline
- elif 'Wsi' not in proto.name and 'format' != p.name and xgl_helper.is_type(p.ty.strip('*').strip('const '), 'struct'):
+ elif 'Wsi' not in proto.name and xgl_helper.is_type(p.ty.strip('*').strip('const '), 'struct'):
sp_param_dict[pindex] = 'index'
pindex += 1
if p.name.endswith('Count'):
@@ -539,37 +539,14 @@
'%s'
'}' % (qual, decl, proto.params[0].name, ret_val, c_call, f_open, log_func, f_close, stmt))
elif "ObjectTracker" == layer:
- obj_type_mapping = {
- "XGL_PHYSICAL_GPU" : "XGL_OBJECT_TYPE_PHYSICAL_GPU",
- "XGL_DEVICE" : "XGL_OBJECT_TYPE_DEVICE",
- "XGL_QUEUE" : "XGL_OBJECT_TYPE_QUEUE",
- "XGL_QUEUE_SEMAPHORE" : "XGL_OBJECT_TYPE_QUEUE_SEMAPHORE",
- "XGL_GPU_MEMORY" : "XGL_OBJECT_TYPE_GPU_MEMORY",
- "XGL_FENCE" : "XGL_OBJECT_TYPE_FENCE",
- "XGL_QUERY_POOL" : "XGL_OBJECT_TYPE_QUERY_POOL",
- "XGL_EVENT" : "XGL_OBJECT_TYPE_EVENT",
- "XGL_IMAGE" : "XGL_OBJECT_TYPE_IMAGE",
- "XGL_DESCRIPTOR_SET" : "XGL_OBJECT_TYPE_DESCRIPTOR_SET",
- "XGL_CMD_BUFFER" : "XGL_OBJECT_TYPE_CMD_BUFFER",
- "XGL_SAMPLER" : "XGL_OBJECT_TYPE_SAMPLER",
- "XGL_PIPELINE" : "XGL_OBJECT_TYPE_PIPELINE",
- "XGL_PIPELINE_DELTA" : "XGL_OBJECT_TYPE_PIPELINE_DELTA",
- "XGL_SHADER" : "XGL_OBJECT_TYPE_SHADER",
- "XGL_IMAGE_VIEW" : "XGL_OBJECT_TYPE_IMAGE_VIEW",
- "XGL_COLOR_ATTACHMENT_VIEW" : "XGL_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW",
- "XGL_DEPTH_STENCIL_VIEW" : "XGL_OBJECT_TYPE_DEPTH_STENCIL_VIEW",
- "XGL_DYNAMIC_VP_STATE_OBJECT" : "XGL_OBJECT_TYPE_VIEWPORT_STATE",
- "XGL_DYNAMIC_RS_STATE_OBJECT" : "XGL_OBJECT_TYPE_RASTER_STATE",
- "XGL_MSAA_STATE_OBJECT" : "XGL_OBJECT_TYPE_MSAA_STATE",
- "XGL_DYNAMIC_CB_STATE_OBJECT" : "XGL_OBJECT_TYPE_COLOR_BLEND_STATE",
- "XGL_DYNAMIC_DS_STATE_OBJECT" : "XGL_OBJECT_TYPE_DEPTH_STENCIL_STATE",
- "XGL_BASE_OBJECT" : "ll_get_obj_type(object)",
- "XGL_OBJECT" : "ll_get_obj_type(object)"
- }
+ obj_type_mapping = {base_t : base_t.replace("XGL_", "XGL_OBJECT_TYPE_") for base_t in xgl.object_type_list}
+ # For the various "super-types" we have to use function to distinguish sub type
+ for obj_type in ["XGL_BASE_OBJECT", "XGL_OBJECT", "XGL_DYNAMIC_STATE_OBJECT"]:
+ obj_type_mapping[obj_type] = "ll_get_obj_type(object)"
decl = proto.c_func(prefix="xgl", attr="XGLAPI")
param0_name = proto.params[0].name
- p0_type = proto.params[0].ty
+ p0_type = proto.params[0].ty.strip('*').strip('const ')
create_line = ''
destroy_line = ''
if 'DbgRegisterMsgCallback' in proto.name:
@@ -595,12 +572,17 @@
using_line += ' pPrev = pTrav;\n'
using_line += ' pTrav = pTrav->pNext;\n'
using_line += ' }\n'
- elif 'GlobalOption' in proto.name:
+ # Special cases for API funcs that don't use an object as first arg
+ elif True in [no_use_proto in proto.name for no_use_proto in ['GlobalOption', 'CreateInstance']]:
using_line = ''
else:
using_line = ' ll_increment_use_count((void*)%s, %s);\n' % (param0_name, obj_type_mapping[p0_type])
- if 'Create' in proto.name or 'Alloc' in proto.name:
- create_line = ' ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-1].name, obj_type_mapping[proto.params[-1].ty.strip('*')])
+ if 'AllocDescriptor' in proto.name: # Allocates array of DSs
+ create_line = ' for (uint32_t i; i < *pCount; i++) {\n'
+ create_line += ' ll_insert_obj((void*)pDescriptorSets[i], XGL_OBJECT_TYPE_DESCRIPTOR_SET);\n'
+ create_line += ' }\n'
+ elif 'Create' in proto.name or 'Alloc' in proto.name:
+ create_line = ' ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-1].name, obj_type_mapping[proto.params[-1].ty.strip('*').strip('const ')])
if 'DestroyObject' in proto.name:
destroy_line = ' ll_destroy_obj((void*)%s);\n' % (param0_name)
using_line = ''
@@ -1028,7 +1010,7 @@
header_txt.append('static void layerCbMsg(XGL_DBG_MSG_TYPE msgType,')
header_txt.append(' XGL_VALIDATION_LEVEL validationLevel,')
header_txt.append(' XGL_BASE_OBJECT srcObject,')
- header_txt.append(' size_t location,')
+ header_txt.append(' size_t location,')
header_txt.append(' int32_t msgCode,')
header_txt.append(' const char* pLayerPrefix,')
header_txt.append(' const char* pMsg)')
@@ -1247,7 +1229,7 @@
if len(sys.argv) < 3 or sys.argv[1] not in subcommands or not os.path.exists(sys.argv[2]):
print("Usage: %s <subcommand> <input_header> [options]" % sys.argv[0])
print
- print("Available sucommands are: %s" % " ".join(subcommands))
+ print("Available subcommands are: %s" % " ".join(subcommands))
exit(1)
hfp = xgl_helper.HeaderFileParser(sys.argv[2])
diff --git a/xgl.py b/xgl.py
index 252ac14..5f09fc1 100644
--- a/xgl.py
+++ b/xgl.py
@@ -223,7 +223,7 @@
Param("XGL_INSTANCE*", "pInstance")]),
Proto("XGL_RESULT", "DestroyInstance",
- [Param("XGL_INSTANCE", "pInstance")]),
+ [Param("XGL_INSTANCE", "instance")]),
Proto("XGL_RESULT", "EnumerateGpus",
[Param("XGL_INSTANCE", "instance"),
@@ -445,11 +445,11 @@
Param("XGL_IMAGE*", "pImage")]),
Proto("XGL_RESULT", "SetFastClearColor",
- [Param("XGL_IMAGE", "pImage"),
+ [Param("XGL_IMAGE", "image"),
Param("const float[4]", "color")]),
Proto("XGL_RESULT", "SetFastClearDepth",
- [Param("XGL_IMAGE", "pImage"),
+ [Param("XGL_IMAGE", "image"),
Param("float", "depth")]),
Proto("XGL_RESULT", "GetImageSubresourceInfo",
@@ -884,6 +884,54 @@
extensions = [core, wsi_x11]
+object_root_list = [
+ "XGL_INSTANCE",
+ "XGL_PHYSICAL_GPU",
+ "XGL_BASE_OBJECT"
+]
+
+object_base_list = [
+ "XGL_DEVICE",
+ "XGL_QUEUE",
+ "XGL_GPU_MEMORY",
+ "XGL_OBJECT"
+]
+
+object_list = [
+ "XGL_BUFFER",
+ "XGL_BUFFER_VIEW",
+ "XGL_IMAGE",
+ "XGL_IMAGE_VIEW",
+ "XGL_COLOR_ATTACHMENT_VIEW",
+ "XGL_DEPTH_STENCIL_VIEW",
+ "XGL_SHADER",
+ "XGL_PIPELINE",
+ "XGL_PIPELINE_DELTA",
+ "XGL_SAMPLER",
+ "XGL_DESCRIPTOR_SET",
+ "XGL_DESCRIPTOR_SET_LAYOUT",
+ "XGL_DESCRIPTOR_REGION",
+ "XGL_DYNAMIC_STATE_OBJECT",
+ "XGL_CMD_BUFFER",
+ "XGL_FENCE",
+ "XGL_QUEUE_SEMAPHORE",
+ "XGL_EVENT",
+ "XGL_QUERY_POOL",
+ "XGL_FRAMEBUFFER",
+ "XGL_RENDER_PASS"
+]
+
+object_dynamic_state_list = [
+ "XGL_DYNAMIC_VP_STATE_OBJECT",
+ "XGL_DYNAMIC_RS_STATE_OBJECT",
+ "XGL_DYNAMIC_CB_STATE_OBJECT",
+ "XGL_DYNAMIC_DS_STATE_OBJECT"
+]
+
+object_type_list = object_root_list + object_base_list + object_list + object_dynamic_state_list
+
+object_parent_list = ["XGL_BASE_OBJECT", "XGL_OBJECT", "XGL_DYNAMIC_STATE_OBJECT"]
+
headers = []
objects = []
protos = []
diff --git a/xgl_helper.py b/xgl_helper.py
index 5a85faa..b650325 100755
--- a/xgl_helper.py
+++ b/xgl_helper.py
@@ -158,7 +158,8 @@
self.typedef_fwd_dict[base_type] = targ_type.strip(';')
self.typedef_rev_dict[targ_type.strip(';')] = base_type
elif parse_enum:
- if 'XGL_MAX_ENUM' not in line and '{' not in line:
+ #if 'XGL_MAX_ENUM' not in line and '{' not in line:
+ if True not in [ens in line for ens in ['{', 'XGL_MAX_ENUM', '_RANGE']]:
self._add_enum(line, base_type, default_enum_val)
default_enum_val += 1
elif parse_struct:
@@ -435,9 +436,9 @@
struct_name = v.replace("_STRUCTURE_TYPE", "")
class_name = self.get_class_name(struct_name)
# TODO : Hand-coded fixes for some exceptions
- if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
- struct_name = 'XGL_PIPELINE_CB_STATE'
- elif 'XGL_SEMAPHORE_CREATE_INFO' in struct_name:
+ #if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
+ #struct_name = 'XGL_PIPELINE_CB_STATE'
+ if 'XGL_SEMAPHORE_CREATE_INFO' in struct_name:
struct_name = 'XGL_QUEUE_SEMAPHORE_CREATE_INFO'
class_name = self.get_class_name(struct_name)
elif 'XGL_SEMAPHORE_OPEN_INFO' in struct_name:
@@ -490,20 +491,20 @@
cast_type = "(void*)"
if not struct_member['ptr']:
cast_type = "(void*)&"
- elif 'BOOL' in struct_member['type']:
+ elif 'bool' in struct_member['type']:
print_type = "s"
member_post = ' ? "TRUE" : "FALSE"'
- elif 'FLOAT' in struct_member['type']:
+ elif 'float' in struct_member['type']:
print_type = "f"
- elif 'UINT64' in struct_member['type']:
+ elif 'uint64' in struct_member['type']:
print_type = "lu"
- elif 'UINT8' in struct_member['type']:
+ elif 'uint8' in struct_member['type']:
print_type = "hu"
- elif '_SIZE' in struct_member['type']:
+ elif '_size' in struct_member['type']:
print_type = "zu"
- elif True in [ui_str in struct_member['type'] for ui_str in ['UINT', '_FLAGS', '_SAMPLE_MASK']]:
+ elif True in [ui_str.lower() in struct_member['type'].lower() for ui_str in ['uint', '_FLAGS', '_SAMPLE_MASK']]:
print_type = "u"
- elif 'INT' in struct_member['type']:
+ elif 'int' in struct_member['type']:
print_type = "i"
elif struct_member['ptr']:
pass
@@ -615,9 +616,9 @@
struct_name = v.replace("_STRUCTURE_TYPE", "")
print_func_name = self._get_sh_func_name(struct_name)
# TODO : Hand-coded fixes for some exceptions
- if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
- struct_name = 'XGL_PIPELINE_CB_STATE'
- elif 'XGL_SEMAPHORE_CREATE_INFO' in struct_name:
+ #if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
+ # struct_name = 'XGL_PIPELINE_CB_STATE'
+ if 'XGL_SEMAPHORE_CREATE_INFO' in struct_name:
struct_name = 'XGL_QUEUE_SEMAPHORE_CREATE_INFO'
print_func_name = self._get_sh_func_name(struct_name)
elif 'XGL_SEMAPHORE_OPEN_INFO' in struct_name:
@@ -709,15 +710,16 @@
index = 0
final_str = ''
for m in sorted(self.struct_dict[s]):
+ deref = ''
if not is_type(self.struct_dict[s][m]['type'], 'enum'):
if is_type(self.struct_dict[s][m]['type'], 'struct') and not self.struct_dict[s][m]['ptr']:
if self.no_addr:
sh_funcs.append(' ss[%u].str("addr");' % (index))
else:
sh_funcs.append(' ss[%u] << &pStruct->%s;' % (index, self.struct_dict[s][m]['name']))
- elif 'BOOL' in self.struct_dict[s][m]['type']:
+ elif 'bool' in self.struct_dict[s][m]['type']:
sh_funcs.append(' ss[%u].str(pStruct->%s ? "TRUE" : "FALSE");' % (index, self.struct_dict[s][m]['name']))
- elif 'UINT8' in self.struct_dict[s][m]['type']:
+ elif 'uint8' in self.struct_dict[s][m]['type']:
sh_funcs.append(' ss[%u] << (uint32_t)pStruct->%s;' % (index, self.struct_dict[s][m]['name']))
else:
(po, pa) = self._get_struct_print_formatted(self.struct_dict[s][m])
@@ -728,7 +730,9 @@
value_print = 'ss[%u].str()' % index
index += 1
else:
- value_print = 'string_%s(pStruct->%s)' % (self.struct_dict[s][m]['type'], self.struct_dict[s][m]['name'])
+ if self.struct_dict[s][m]['ptr']:
+ deref = '*'
+ value_print = 'string_%s(%spStruct->%s)' % (self.struct_dict[s][m]['type'], deref, self.struct_dict[s][m]['name'])
final_str += ' + prefix + "%s = " + %s + "\\n"' % (self.struct_dict[s][m]['name'], value_print)
final_str = final_str[3:] # strip off the initial ' + '
if 0 != num_stps:
@@ -748,9 +752,9 @@
struct_name = v.replace("_STRUCTURE_TYPE", "")
print_func_name = self._get_sh_func_name(struct_name)
# TODO : Hand-coded fixes for some exceptions
- if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
- struct_name = 'XGL_PIPELINE_CB_STATE'
- elif 'XGL_SEMAPHORE_CREATE_INFO' in struct_name:
+ #if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
+ # struct_name = 'XGL_PIPELINE_CB_STATE'
+ if 'XGL_SEMAPHORE_CREATE_INFO' in struct_name:
struct_name = 'XGL_QUEUE_SEMAPHORE_CREATE_INFO'
print_func_name = self._get_sh_func_name(struct_name)
elif 'XGL_SEMAPHORE_OPEN_INFO' in struct_name:
@@ -774,8 +778,8 @@
if is_type(self.struct_dict[s][member]['type'], 'struct'): # print struct address for now
struct_array.insert(0, self.struct_dict[s][member])
elif self.struct_dict[s][member]['ptr']:
- # Special case for VOID* named "pNext"
- if "VOID" in self.struct_dict[s][member]['type'] and "pNext" == self.struct_dict[s][member]['name']:
+ # Special case for void* named "pNext"
+ if "void" in self.struct_dict[s][member]['type'] and "pNext" == self.struct_dict[s][member]['name']:
struct_array.insert(0, self.struct_dict[s][member])
return (' %sprintf("%%*s %s", m_indent, ""%s);' % (extra_indent, p_out, p_arg), struct_array)
@@ -888,7 +892,8 @@
for s in self.struct_dict:
sh_funcs.append('uint32_t %s(const %s* pStruct)\n{' % (self._get_vh_func_name(s), typedef_fwd_dict[s]))
for m in sorted(self.struct_dict[s]):
- if is_type(self.struct_dict[s][m]['type'], 'enum'):
+ # TODO : Need to handle arrays of enums like in XGL_RENDER_PASS_CREATE_INFO struct
+ if is_type(self.struct_dict[s][m]['type'], 'enum') and not self.struct_dict[s][m]['ptr']:
sh_funcs.append(' if (!validate_%s(pStruct->%s))\n return 0;' % (self.struct_dict[s][m]['type'], self.struct_dict[s][m]['name']))
# TODO : Need a little refinement to this code to make sure type of struct matches expected input (ptr, const...)
if is_type(self.struct_dict[s][m]['type'], 'struct'):
@@ -1099,20 +1104,20 @@
cast_type = "(void*)"
if not struct_member['ptr']:
cast_type = "(void*)&"
- elif 'BOOL' in struct_member['type']:
+ elif 'bool' in struct_member['type']:
print_type = "s"
member_post = ' ? "TRUE" : "FALSE"'
- elif 'FLOAT' in struct_member['type']:
+ elif 'float' in struct_member['type']:
print_type = "f"
- elif 'UINT64' in struct_member['type']:
+ elif 'uint64' in struct_member['type']:
print_type = "lu"
- elif 'UINT8' in struct_member['type']:
+ elif 'uint8' in struct_member['type']:
print_type = "hu"
elif '_SIZE' in struct_member['type']:
print_type = "zu"
- elif True in [ui_str in struct_member['type'] for ui_str in ['UINT', '_FLAGS', '_SAMPLE_MASK']]:
+ elif True in [ui_str in struct_member['type'] for ui_str in ['uint', '_FLAGS', '_SAMPLE_MASK']]:
print_type = "u"
- elif 'INT' in struct_member['type']:
+ elif 'int' in struct_member['type']:
print_type = "i"
elif struct_member['ptr']:
pass
@@ -1260,9 +1265,9 @@
struct_name = v.replace("_STRUCTURE_TYPE", "")
print_func_name = self._get_gv_func_name(struct_name)
# TODO : Hand-coded fixes for some exceptions
- if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
- struct_name = 'XGL_PIPELINE_CB_STATE'
- elif 'XGL_SEMAPHORE_CREATE_INFO' in struct_name:
+ #if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
+ # struct_name = 'XGL_PIPELINE_CB_STATE'
+ if 'XGL_SEMAPHORE_CREATE_INFO' in struct_name:
struct_name = 'XGL_QUEUE_SEMAPHORE_CREATE_INFO'
print_func_name = self._get_gv_func_name(struct_name)
elif 'XGL_SEMAPHORE_OPEN_INFO' in struct_name: