vulkan: API renaming
VK_DEVICE_QUEUE_CREATE_INFO => VkDeviceQueueCreateInfo
VK_DEVICE_CREATE_INFO => VkDeviceCreateInfo
VK_INSTANCE_CREATE_INFO => VkInstanceCreateInfo
VK_LAYER_CREATE_INFO => VkLayerCreateInfo
VK_MEMORY_ALLOC_INFO => VkMemoryAllocInfo
VK_MEMORY_ALLOC_IMAGE_INFO => VkMemoryAllocImageInfo
VK_MEMORY_ALLOC_BUFFER_INFO => VkMemoryAllocBufferInfo
VK_BUFFER_CREATE_INFO => VkBufferCreateInfo
VK_BUFFER_VIEW_CREATE_INFO => VkBufferViewCreateInfo
diff --git a/layers/basic.cpp b/layers/basic.cpp
index dbbb491..402adb6 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -86,7 +86,7 @@
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
{
VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 6806882..5e4a95f 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -262,7 +262,7 @@
delete (*ii).second;
}
}
-static VK_BUFFER_VIEW_CREATE_INFO* getBufferViewCreateInfo(VK_BUFFER_VIEW view)
+static VkBufferViewCreateInfo* getBufferViewCreateInfo(VK_BUFFER_VIEW view)
{
loader_platform_thread_lock_mutex(&globalLock);
if (bufferMap.find(view) == bufferMap.end()) {
@@ -1111,7 +1111,7 @@
VK_UPDATE_AS_COPY* pUAC = NULL;
VK_SAMPLER_CREATE_INFO* pSCI = NULL;
VK_IMAGE_VIEW_CREATE_INFO* pIVCI = NULL;
- VK_BUFFER_VIEW_CREATE_INFO* pBVCI = NULL;
+ VkBufferViewCreateInfo* pBVCI = NULL;
void** ppNextPtr = NULL;
void* pSaveNext = NULL;
for (i=0; i < pSet->descriptorCount; i++) {
@@ -1156,7 +1156,7 @@
pBVCI = getBufferViewCreateInfo(pUB->pBufferViews[i-pUB->arrayIndex].view);
if (pBVCI) {
sprintf(tmp_str, "BUFFER_VIEW%u", i);
- fprintf(pOutFile, "%s", vk_gv_print_vk_buffer_view_create_info(pBVCI, tmp_str));
+ fprintf(pOutFile, "%s", vk_gv_print_vkbufferviewcreateinfo(pBVCI, tmp_str));
fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str());
}
break;
@@ -1441,7 +1441,7 @@
}
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
{
VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
@@ -1522,7 +1522,7 @@
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView)
{
VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
if (VK_SUCCESS == result) {
diff --git a/layers/draw_state.h b/layers/draw_state.h
index 0bf33c4..426bf38 100644
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -116,7 +116,7 @@
typedef struct _BUFFER_NODE {
VK_BUFFER_VIEW buffer;
- VK_BUFFER_VIEW_CREATE_INFO createInfo;
+ VkBufferViewCreateInfo createInfo;
VK_BUFFER_VIEW_ATTACH_INFO attachInfo;
} BUFFER_NODE;
diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c
index 12caf3c..7b1c4ad 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -62,15 +62,15 @@
memcpy(*ppDest, pSrc, size);
}
-VK_DEVICE_CREATE_INFO* glv_deepcopy_VK_DEVICE_CREATE_INFO(const VK_DEVICE_CREATE_INFO* pSrcCreateInfo)
+VkDeviceCreateInfo* glv_deepcopy_VkDeviceCreateInfo(const VkDeviceCreateInfo* pSrcCreateInfo)
{
- VK_DEVICE_CREATE_INFO* pDestCreateInfo;
+ VkDeviceCreateInfo* pDestCreateInfo;
- // NOTE: partially duplicated code from add_VK_DEVICE_CREATE_INFO_to_packet(...)
+ // NOTE: partially duplicated code from add_VkDeviceCreateInfo_to_packet(...)
{
uint32_t i;
- glv_vk_malloc_and_copy((void**)&pDestCreateInfo, sizeof(VK_DEVICE_CREATE_INFO), pSrcCreateInfo);
- glv_vk_malloc_and_copy((void**)&pDestCreateInfo->pRequestedQueues, pSrcCreateInfo->queueRecordCount*sizeof(VK_DEVICE_QUEUE_CREATE_INFO), pSrcCreateInfo->pRequestedQueues);
+ glv_vk_malloc_and_copy((void**)&pDestCreateInfo, sizeof(VkDeviceCreateInfo), pSrcCreateInfo);
+ glv_vk_malloc_and_copy((void**)&pDestCreateInfo->pRequestedQueues, pSrcCreateInfo->queueRecordCount*sizeof(VkDeviceQueueCreateInfo), pSrcCreateInfo->pRequestedQueues);
if (pSrcCreateInfo->extensionCount > 0)
{
@@ -80,29 +80,29 @@
glv_vk_malloc_and_copy((void**)&pDestCreateInfo->ppEnabledExtensionNames[i], strlen(pSrcCreateInfo->ppEnabledExtensionNames[i]) + 1, pSrcCreateInfo->ppEnabledExtensionNames[i]);
}
}
- VK_LAYER_CREATE_INFO *pSrcNext = ( VK_LAYER_CREATE_INFO *) pSrcCreateInfo->pNext;
- VK_LAYER_CREATE_INFO **ppDstNext = ( VK_LAYER_CREATE_INFO **) &pDestCreateInfo->pNext;
+ VkLayerCreateInfo *pSrcNext = ( VkLayerCreateInfo *) pSrcCreateInfo->pNext;
+ VkLayerCreateInfo **ppDstNext = ( VkLayerCreateInfo **) &pDestCreateInfo->pNext;
while (pSrcNext != NULL)
{
if ((pSrcNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
{
- glv_vk_malloc_and_copy((void**)ppDstNext, sizeof(VK_LAYER_CREATE_INFO), pSrcNext);
+ glv_vk_malloc_and_copy((void**)ppDstNext, sizeof(VkLayerCreateInfo), pSrcNext);
glv_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames, pSrcNext->layerCount * sizeof(char*), pSrcNext->ppActiveLayerNames);
for (i = 0; i < pSrcNext->layerCount; i++)
{
glv_vk_malloc_and_copy((void**)&(*ppDstNext)->ppActiveLayerNames[i], strlen(pSrcNext->ppActiveLayerNames[i]) + 1, pSrcNext->ppActiveLayerNames[i]);
}
- ppDstNext = (VK_LAYER_CREATE_INFO**) &(*ppDstNext)->pNext;
+ ppDstNext = (VkLayerCreateInfo**) &(*ppDstNext)->pNext;
}
- pSrcNext = (VK_LAYER_CREATE_INFO*) pSrcNext->pNext;
+ pSrcNext = (VkLayerCreateInfo*) pSrcNext->pNext;
}
}
return pDestCreateInfo;
}
-void glv_deepfree_VK_DEVICE_CREATE_INFO(VK_DEVICE_CREATE_INFO* pCreateInfo)
+void glv_deepfree_VkDeviceCreateInfo(VkDeviceCreateInfo* pCreateInfo)
{
uint32_t i;
if (pCreateInfo->pRequestedQueues != NULL)
@@ -119,10 +119,10 @@
free((void*)pCreateInfo->ppEnabledExtensionNames);
}
- VK_LAYER_CREATE_INFO *pSrcNext = (VK_LAYER_CREATE_INFO*)pCreateInfo->pNext;
+ VkLayerCreateInfo *pSrcNext = (VkLayerCreateInfo*)pCreateInfo->pNext;
while (pSrcNext != NULL)
{
- VK_LAYER_CREATE_INFO* pTmp = (VK_LAYER_CREATE_INFO*)pSrcNext->pNext;
+ VkLayerCreateInfo* pTmp = (VkLayerCreateInfo*)pSrcNext->pNext;
if ((pSrcNext->sType == VK_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pSrcNext->layerCount > 0)
{
for (i = 0; i < pSrcNext->layerCount; i++)
@@ -139,11 +139,11 @@
free(pCreateInfo);
}
-void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
{
pDest->gpu = gpu;
- pDest->pCreateInfo = glv_deepcopy_VK_DEVICE_CREATE_INFO(pCreateInfo);
+ pDest->pCreateInfo = glv_deepcopy_VkDeviceCreateInfo(pCreateInfo);
pDest->pDevice = (VK_DEVICE*)malloc(sizeof(VK_DEVICE));
*pDest->pDevice = *pDevice;
@@ -153,7 +153,7 @@
{
memset(&pSrc->gpu, 0, sizeof(VK_PHYSICAL_GPU));
- glv_deepfree_VK_DEVICE_CREATE_INFO(pSrc->pCreateInfo);
+ glv_deepfree_VkDeviceCreateInfo(pSrc->pCreateInfo);
pSrc->pCreateInfo = NULL;
free(pSrc->pDevice);
@@ -267,7 +267,7 @@
}
// Note: the parameters after pSnapshot match the order of vkCreateDevice(..)
-static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
{
GLV_VK_SNAPSHOT_LL_NODE* pNode = snapshot_insert_object(pSnapshot, *pDevice, VK_OBJECT_TYPE_DEVICE);
pNode->obj.pStruct = malloc(sizeof(GLV_VK_SNAPSHOT_DEVICE_NODE));
@@ -463,7 +463,7 @@
//=============================================================================
// vulkan entrypoints
//=============================================================================
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VK_INSTANCE* pInstance)
{
VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
loader_platform_thread_lock_mutex(&objLock);
@@ -499,7 +499,7 @@
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
{
VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
@@ -605,7 +605,7 @@
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo * pAllocInfo, VK_GPU_MEMORY* pMem)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
@@ -901,7 +901,7 @@
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
@@ -917,7 +917,7 @@
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE);
@@ -1809,7 +1809,7 @@
while (pDeviceNode != NULL)
{
GLV_VK_SNAPSHOT_DEVICE_NODE* pDev = (GLV_VK_SNAPSHOT_DEVICE_NODE*)pDeviceNode->obj.pStruct;
- char * createInfoStr = vk_print_vk_device_create_info(pDev->params.pCreateInfo, "\t\t");
+ char * createInfoStr = vk_print_vkdevicecreateinfo(pDev->params.pCreateInfo, "\t\t");
sprintf(str, "\t%s obj %p:\n%s", string_VK_OBJECT_TYPE(VK_OBJECT_TYPE_DEVICE), pDeviceNode->obj.pVkObject, createInfoStr);
layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDeviceNode->obj.pVkObject, 0, GLVSNAPSHOT_SNAPSHOT_DATA, LAYER_ABBREV_STR, str);
pDeviceNode = pDeviceNode->pNextObj;
diff --git a/layers/glave_snapshot.h b/layers/glave_snapshot.h
index 999736d..f22915c 100644
--- a/layers/glave_snapshot.h
+++ b/layers/glave_snapshot.h
@@ -174,12 +174,12 @@
typedef struct _GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS
{
VK_PHYSICAL_GPU gpu;
- VK_DEVICE_CREATE_INFO* pCreateInfo;
+ VkDeviceCreateInfo* pCreateInfo;
VK_DEVICE* pDevice;
} GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS;
-VK_DEVICE_CREATE_INFO* glv_deepcopy_xgl_device_create_info(const VK_DEVICE_CREATE_INFO* pSrcCreateInfo);void glv_deepfree_xgl_device_create_info(VK_DEVICE_CREATE_INFO* pCreateInfo);
-void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice);
+VkDeviceCreateInfo* glv_deepcopy_xgl_device_create_info(const VkDeviceCreateInfo* pSrcCreateInfo);void glv_deepfree_xgl_device_create_info(VkDeviceCreateInfo* pCreateInfo);
+void glv_vk_snapshot_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice);
void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc);
//=============================================================================
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 71b8a5a..c05e07e 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -345,14 +345,14 @@
return pMemObjInfo;
}
-static void addMemObjInfo(const VK_GPU_MEMORY mem, const VK_MEMORY_ALLOC_INFO* pAllocInfo)
+static void addMemObjInfo(const VK_GPU_MEMORY mem, const VkMemoryAllocInfo* pAllocInfo)
{
MT_MEM_OBJ_INFO* pInfo = new MT_MEM_OBJ_INFO;
pInfo->refCount = 0;
- memset(&pInfo->allocInfo, 0, sizeof(VK_MEMORY_ALLOC_INFO));
+ memset(&pInfo->allocInfo, 0, sizeof(VkMemoryAllocInfo));
if (pAllocInfo) { // MEM alloc created by vkWsiX11CreatePresentableImage() doesn't have alloc info struct
- memcpy(&pInfo->allocInfo, pAllocInfo, sizeof(VK_MEMORY_ALLOC_INFO));
+ memcpy(&pInfo->allocInfo, pAllocInfo, sizeof(VkMemoryAllocInfo));
// TODO: Update for real hardware, actually process allocation info structures
pInfo->allocInfo.pNext = NULL;
}
@@ -734,7 +734,7 @@
sprintf(str, " Ref Count: %u", pInfo->refCount);
layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
if (0 != pInfo->allocInfo.allocationSize) {
- string pAllocInfoMsg = vk_print_vk_memory_alloc_info(&pInfo->allocInfo, "{MEM}INFO : ");
+ string pAllocInfoMsg = vk_print_vkmemoryallocinfo(&pInfo->allocInfo, "{MEM}INFO : ");
sprintf(str, " Mem Alloc info:\n%s", pAllocInfoMsg.c_str());
layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str);
} else {
@@ -821,7 +821,7 @@
}
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
{
VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
@@ -999,7 +999,7 @@
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem)
{
VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
// TODO : Track allocations and overall size here
@@ -1262,23 +1262,23 @@
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer)
{
VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(VK_BUFFER_CREATE_INFO), "buffer");
+ addObjectInfo(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferCreateInfo), "buffer");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView)
{
VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_BUFFER_VIEW_CREATE_INFO), "buffer_view");
+ addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferViewCreateInfo), "buffer_view");
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h
index bb12132..d3a8608 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -86,7 +86,7 @@
struct MT_MEM_OBJ_INFO {
uint32_t refCount; // Count of references (obj bindings or CB use)
VK_GPU_MEMORY mem;
- VK_MEMORY_ALLOC_INFO allocInfo;
+ VkMemoryAllocInfo allocInfo;
list<VK_OBJECT> pObjBindings; // list container of objects bound to this memory
list<VK_CMD_BUFFER> pCmdBufferBindings; // list container of cmd buffers that reference this mem object
};
diff --git a/layers/multi.cpp b/layers/multi.cpp
index a4856eb..3f967d6 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -62,7 +62,7 @@
#endif
-VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo,
+VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo,
VK_DEVICE* pDevice)
{
VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
@@ -163,7 +163,7 @@
}
}
-VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo,
+VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo,
VK_DEVICE* pDevice)
{
VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index fb1189e..9be48ad 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -124,7 +124,7 @@
}
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VK_INSTANCE* pInstance)
{
PreCreateInstance(pCreateInfo->pAppInfo, pCreateInfo->pAllocCb);
VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance);
@@ -160,7 +160,7 @@
return result;
}
-void PreCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo)
+void PreCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo)
{
if(gpu == nullptr)
{
@@ -172,7 +172,7 @@
if(pCreateInfo == nullptr)
{
- char const str[] = "vkCreateDevice parameter, VK_DEVICE_CREATE_INFO* pCreateInfo, is "\
+ char const str[] = "vkCreateDevice parameter, VkDeviceCreateInfo* pCreateInfo, is "\
"nullptr (precondition).";
layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
@@ -196,7 +196,7 @@
if(pCreateInfo->pRequestedQueues == nullptr)
{
- char const str[] = "vkCreateDevice parameter, VK_DEVICE_QUEUE_CREATE_INFO* pCreateInfo->pRequestedQueues, is "\
+ char const str[] = "vkCreateDevice parameter, VkDeviceQueueCreateInfo* pCreateInfo->pRequestedQueues, is "\
"nullptr (precondition).";
layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
return;
@@ -204,10 +204,10 @@
for(uint32_t i = 0; i < pCreateInfo->queueRecordCount; ++i)
{
- if(!vk_validate_vk_device_queue_create_info(&(pCreateInfo->pRequestedQueues[i])))
+ if(!vk_validate_vkdevicequeuecreateinfo(&(pCreateInfo->pRequestedQueues[i])))
{
std::stringstream ss;
- ss << "vkCreateDevice parameter, VK_DEVICE_QUEUE_CREATE_INFO pCreateInfo->pRequestedQueues[" << i <<
+ ss << "vkCreateDevice parameter, VkDeviceQueueCreateInfo pCreateInfo->pRequestedQueues[" << i <<
"], is invalid (precondition).";
layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str());
continue;
@@ -241,7 +241,7 @@
}
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice)
{
VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
pCurObj = gpuw;
@@ -331,14 +331,13 @@
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem)
{
char str[1024];
if (!pAllocInfo) {
sprintf(str, "Struct ptr parameter pAllocInfo to function AllocMemory is NULL.");
layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
- }
- else if (!vk_validate_vk_memory_alloc_info(pAllocInfo)) {
+ } else if (!vk_validate_vkmemoryallocinfo(pAllocInfo)) {
sprintf(str, "Parameter pAllocInfo to function AllocMemory contains an invalid value.");
layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
@@ -640,14 +639,14 @@
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateBuffer is NULL.");
layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!vk_validate_vk_buffer_create_info(pCreateInfo)) {
+ else if (!vk_validate_vkbuffercreateinfo(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateBuffer contains an invalid value.");
layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
@@ -655,14 +654,14 @@
return result;
}
-VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView)
+VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView)
{
char str[1024];
if (!pCreateInfo) {
sprintf(str, "Struct ptr parameter pCreateInfo to function CreateBufferView is NULL.");
layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- else if (!vk_validate_vk_buffer_view_create_info(pCreateInfo)) {
+ else if (!vk_validate_vkbufferviewcreateinfo(pCreateInfo)) {
sprintf(str, "Parameter pCreateInfo to function CreateBufferView contains an invalid value.");
layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}