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/include/vulkan.h b/include/vulkan.h
index b3527c0..ef5ce64 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -1396,25 +1396,25 @@
VK_FREE_FUNCTION pfnFree;
} VK_ALLOC_CALLBACKS;
-typedef struct _VK_DEVICE_QUEUE_CREATE_INFO
+typedef struct _VkDeviceQueueCreateInfo
{
uint32_t queueNodeIndex;
uint32_t queueCount;
-} VK_DEVICE_QUEUE_CREATE_INFO;
+} VkDeviceQueueCreateInfo;
-typedef struct _VK_DEVICE_CREATE_INFO
+typedef struct _VkDeviceCreateInfo
{
VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
const void* pNext; // Pointer to next structure
uint32_t queueRecordCount;
- const VK_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues;
+ const VkDeviceQueueCreateInfo* pRequestedQueues;
uint32_t extensionCount;
const char*const* ppEnabledExtensionNames;
VK_VALIDATION_LEVEL maxValidationLevel;
VK_FLAGS flags; // VK_DEVICE_CREATE_FLAGS
-} VK_DEVICE_CREATE_INFO;
+} VkDeviceCreateInfo;
-typedef struct _VK_INSTANCE_CREATE_INFO
+typedef struct _VkInstanceCreateInfo
{
VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
const void* pNext; // Pointer to next structure
@@ -1422,16 +1422,16 @@
const VK_ALLOC_CALLBACKS* pAllocCb;
uint32_t extensionCount;
const char*const* ppEnabledExtensionNames; // layer or extension name to be enabled
-} VK_INSTANCE_CREATE_INFO;
+} VkInstanceCreateInfo;
-// can be added to VK_DEVICE_CREATE_INFO or VK_INSTANCE_CREATE_INFO via pNext
-typedef struct _VK_LAYER_CREATE_INFO
+// can be added to VkDeviceCreateInfo or VkInstanceCreateInfo via pNext
+typedef struct _VkLayerCreateInfo
{
VK_STRUCTURE_TYPE sType; // Should be VK_STRUCTURE_TYPE_LAYER_CREATE_INFO
const void* pNext; // Pointer to next structure
uint32_t layerCount;
const char *const* ppActiveLayerNames; // layer name from the layer's vkEnumerateLayers())
-} VK_LAYER_CREATE_INFO;
+} VkLayerCreateInfo;
typedef struct _VK_PHYSICAL_GPU_QUEUE_PROPERTIES
{
@@ -1448,7 +1448,7 @@
bool32_t supportsPinning;
} VK_PHYSICAL_GPU_MEMORY_PROPERTIES;
-typedef struct _VK_MEMORY_ALLOC_INFO
+typedef struct _VkMemoryAllocInfo
{
VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
const void* pNext; // Pointer to next structure
@@ -1456,27 +1456,27 @@
VK_FLAGS memProps; // VK_MEMORY_PROPERTY_FLAGS
VK_MEMORY_TYPE memType;
VK_MEMORY_PRIORITY memPriority;
-} VK_MEMORY_ALLOC_INFO;
+} VkMemoryAllocInfo;
-// This structure is included in the VK_MEMORY_ALLOC_INFO chain
+// This structure is included in the VkMemoryAllocInfo chain
// for memory regions allocated for buffer usage.
-typedef struct _VK_MEMORY_ALLOC_BUFFER_INFO
+typedef struct _VkMemoryAllocBufferInfo
{
VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO
const void* pNext; // Pointer to next structure
VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS
-} VK_MEMORY_ALLOC_BUFFER_INFO;
+} VkMemoryAllocBufferInfo;
-// This structure is included in the VK_MEMORY_ALLOC_INFO chain
+// This structure is included in the VkMemoryAllocInfo chain
// for memory regions allocated for image usage.
-typedef struct _VK_MEMORY_ALLOC_IMAGE_INFO
+typedef struct _VkMemoryAllocImageInfo
{
VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO
const void* pNext; // Pointer to next structure
VK_FLAGS usage; // VK_IMAGE_USAGE_FLAGS
VK_IMAGE_FORMAT_CLASS formatClass;
uint32_t samples;
-} VK_MEMORY_ALLOC_IMAGE_INFO;
+} VkMemoryAllocImageInfo;
typedef struct _VK_MEMORY_OPEN_INFO
{
@@ -1593,16 +1593,16 @@
uint32_t count;
} VK_UPDATE_AS_COPY;
-typedef struct _VK_BUFFER_CREATE_INFO
+typedef struct _VkBufferCreateInfo
{
VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
const void* pNext; // Pointer to next structure.
VK_GPU_SIZE size; // Specified in bytes
VK_FLAGS usage; // VK_BUFFER_USAGE_FLAGS
VK_FLAGS flags; // VK_BUFFER_CREATE_FLAGS
-} VK_BUFFER_CREATE_INFO;
+} VkBufferCreateInfo;
-typedef struct _VK_BUFFER_VIEW_CREATE_INFO
+typedef struct _VkBufferViewCreateInfo
{
VK_STRUCTURE_TYPE sType; // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
const void* pNext; // Pointer to next structure.
@@ -1611,7 +1611,7 @@
VK_FORMAT format; // Optionally specifies format of elements
VK_GPU_SIZE offset; // Specified in bytes
VK_GPU_SIZE range; // View size specified in bytes
-} VK_BUFFER_VIEW_CREATE_INFO;
+} VkBufferViewCreateInfo;
typedef struct _VK_IMAGE_SUBRESOURCE
{
@@ -2266,12 +2266,12 @@
// ------------------------------------------------------------------------------------------------
// API functions
-typedef VK_RESULT (VKAPI *vkCreateInstanceType)(const VK_INSTANCE_CREATE_INFO* pCreateInfo, VK_INSTANCE* pInstance);
+typedef VK_RESULT (VKAPI *vkCreateInstanceType)(const VkInstanceCreateInfo* pCreateInfo, VK_INSTANCE* pInstance);
typedef VK_RESULT (VKAPI *vkDestroyInstanceType)(VK_INSTANCE instance);
typedef VK_RESULT (VKAPI *vkEnumerateGpusType)(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus);
typedef VK_RESULT (VKAPI *vkGetGpuInfoType)(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData);
typedef void * (VKAPI *vkGetProcAddrType)(VK_PHYSICAL_GPU gpu, const char * pName);
-typedef VK_RESULT (VKAPI *vkCreateDeviceType)(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo, VK_DEVICE* pDevice);
+typedef VK_RESULT (VKAPI *vkCreateDeviceType)(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice);
typedef VK_RESULT (VKAPI *vkDestroyDeviceType)(VK_DEVICE device);
typedef VK_RESULT (VKAPI *vkGetExtensionSupportType)(VK_PHYSICAL_GPU gpu, const char* pExtName);
typedef VK_RESULT (VKAPI *vkEnumerateLayersType)(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved);
@@ -2281,7 +2281,7 @@
typedef VK_RESULT (VKAPI *vkQueueRemoveMemReferenceType)(VK_QUEUE queue, VK_GPU_MEMORY mem);
typedef VK_RESULT (VKAPI *vkQueueWaitIdleType)(VK_QUEUE queue);
typedef VK_RESULT (VKAPI *vkDeviceWaitIdleType)(VK_DEVICE device);
-typedef VK_RESULT (VKAPI *vkAllocMemoryType)(VK_DEVICE device, const VK_MEMORY_ALLOC_INFO* pAllocInfo, VK_GPU_MEMORY* pMem);
+typedef VK_RESULT (VKAPI *vkAllocMemoryType)(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem);
typedef VK_RESULT (VKAPI *vkFreeMemoryType)(VK_GPU_MEMORY mem);
typedef VK_RESULT (VKAPI *vkSetMemoryPriorityType)(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority);
typedef VK_RESULT (VKAPI *vkMapMemoryType)(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData);
@@ -2311,8 +2311,8 @@
typedef VK_RESULT (VKAPI *vkCreateQueryPoolType)(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool);
typedef VK_RESULT (VKAPI *vkGetQueryPoolResultsType)(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData);
typedef VK_RESULT (VKAPI *vkGetFormatInfoType)(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData);
-typedef VK_RESULT (VKAPI *vkCreateBufferType)(VK_DEVICE device, const VK_BUFFER_CREATE_INFO* pCreateInfo, VK_BUFFER* pBuffer);
-typedef VK_RESULT (VKAPI *vkCreateBufferViewType)(VK_DEVICE device, const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo, VK_BUFFER_VIEW* pView);
+typedef VK_RESULT (VKAPI *vkCreateBufferType)(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer);
+typedef VK_RESULT (VKAPI *vkCreateBufferViewType)(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView);
typedef VK_RESULT (VKAPI *vkCreateImageType)(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage);
typedef VK_RESULT (VKAPI *vkGetImageSubresourceInfoType)(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData);
typedef VK_RESULT (VKAPI *vkCreateImageViewType)(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView);
@@ -2386,7 +2386,7 @@
// GPU initialization
VK_RESULT VKAPI vkCreateInstance(
- const VK_INSTANCE_CREATE_INFO* pCreateInfo,
+ const VkInstanceCreateInfo* pCreateInfo,
VK_INSTANCE* pInstance);
VK_RESULT VKAPI vkDestroyInstance(
@@ -2412,7 +2412,7 @@
VK_RESULT VKAPI vkCreateDevice(
VK_PHYSICAL_GPU gpu,
- const VK_DEVICE_CREATE_INFO* pCreateInfo,
+ const VkDeviceCreateInfo* pCreateInfo,
VK_DEVICE* pDevice);
VK_RESULT VKAPI vkDestroyDevice(
@@ -2466,7 +2466,7 @@
VK_RESULT VKAPI vkAllocMemory(
VK_DEVICE device,
- const VK_MEMORY_ALLOC_INFO* pAllocInfo,
+ const VkMemoryAllocInfo* pAllocInfo,
VK_GPU_MEMORY* pMem);
VK_RESULT VKAPI vkFreeMemory(
@@ -2630,14 +2630,14 @@
VK_RESULT VKAPI vkCreateBuffer(
VK_DEVICE device,
- const VK_BUFFER_CREATE_INFO* pCreateInfo,
+ const VkBufferCreateInfo* pCreateInfo,
VK_BUFFER* pBuffer);
// Buffer view functions
VK_RESULT VKAPI vkCreateBufferView(
VK_DEVICE device,
- const VK_BUFFER_VIEW_CREATE_INFO* pCreateInfo,
+ const VkBufferViewCreateInfo* pCreateInfo,
VK_BUFFER_VIEW* pView);
// Image functions
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);
}
diff --git a/loader/loader.c b/loader/loader.c
index 60c5f21..377de81 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -714,7 +714,7 @@
return count;
}
-static uint32_t loader_get_layer_libs(struct loader_icd *icd, uint32_t gpu_index, const VK_DEVICE_CREATE_INFO* pCreateInfo, struct layer_name_pair **ppLayerNames)
+static uint32_t loader_get_layer_libs(struct loader_icd *icd, uint32_t gpu_index, const VkDeviceCreateInfo* pCreateInfo, struct layer_name_pair **ppLayerNames)
{
static struct layer_name_pair layerNames[MAX_LAYER_LIBRARIES];
const char *lib_name = NULL;
@@ -788,7 +788,7 @@
}
}
-extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo)
+extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo)
{
uint32_t gpu_index;
uint32_t count;
@@ -858,7 +858,7 @@
}
LOADER_EXPORT VK_RESULT VKAPI vkCreateInstance(
- const VK_INSTANCE_CREATE_INFO* pCreateInfo,
+ const VkInstanceCreateInfo* pCreateInfo,
VK_INSTANCE* pInstance)
{
static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_icd);
diff --git a/loader/loader.h b/loader/loader.h
index 1817386..f40a36a 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -74,7 +74,7 @@
return loader_get_data(wrap->baseObject);
}
-extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VK_DEVICE_CREATE_INFO* pCreateInfo);
+extern uint32_t loader_activate_layers(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo);
#define MAX_LAYER_LIBRARIES 64
#endif /* LOADER_H */
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index 848fc83..b6dbc6d 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -778,9 +778,9 @@
// VK_RESULT VKAPI vkAllocMemory(
// VK_DEVICE device,
- // const VK_MEMORY_ALLOC_INFO* pAllocInfo,
+ // const VkMemoryAllocInfo* pAllocInfo,
// VK_GPU_MEMORY* pMem);
- VK_MEMORY_ALLOC_INFO mem_info;
+ VkMemoryAllocInfo mem_info;
VK_GPU_MEMORY event_mem;
ASSERT_NE(0, mem_req.size) << "vkGetObjectInfo (Event): Failed - expect events to require memory";
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index 8898ae7..cf81836 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -93,7 +93,7 @@
this->app_info.pEngineName = "unittest";
this->app_info.engineVersion = 1;
this->app_info.apiVersion = VK_API_VERSION;
- VK_INSTANCE_CREATE_INFO inst_info = {};
+ VkInstanceCreateInfo inst_info = {};
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pAppInfo = &app_info;
@@ -211,11 +211,11 @@
size_t img_reqs_size = sizeof(VK_IMAGE_MEMORY_REQUIREMENTS);
uint32_t num_allocations = 0;
size_t num_alloc_size = sizeof(num_allocations);
- VK_MEMORY_ALLOC_IMAGE_INFO img_alloc = {};
+ VkMemoryAllocImageInfo img_alloc = {};
img_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO;
img_alloc.pNext = NULL;
- VK_MEMORY_ALLOC_INFO mem_info = {};
+ VkMemoryAllocInfo mem_info = {};
mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.pNext = &img_alloc;
diff --git a/tests/init.cpp b/tests/init.cpp
index 9de9dfc..f40f435 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -98,7 +98,7 @@
this->app_info.pEngineName = "unittest";
this->app_info.engineVersion = 1;
this->app_info.apiVersion = VK_API_VERSION;
- VK_INSTANCE_CREATE_INFO inst_info = {};
+ VkInstanceCreateInfo inst_info = {};
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pAppInfo = &app_info;
@@ -143,7 +143,7 @@
char *layers[16];
size_t layer_count;
char layer_buf[16][256];
- VK_INSTANCE_CREATE_INFO inst_info = {};
+ VkInstanceCreateInfo inst_info = {};
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pAppInfo = &app_info;
@@ -184,7 +184,7 @@
TEST_F(XglTest, AllocMemory) {
VK_RESULT err;
- VK_MEMORY_ALLOC_INFO alloc_info = {};
+ VkMemoryAllocInfo alloc_info = {};
VK_GPU_MEMORY gpu_mem;
uint8_t *pData;
@@ -239,9 +239,9 @@
// VK_RESULT VKAPI vkAllocMemory(
// VK_DEVICE device,
- // const VK_MEMORY_ALLOC_INFO* pAllocInfo,
+ // const VkMemoryAllocInfo* pAllocInfo,
// VK_GPU_MEMORY* pMem);
- VK_MEMORY_ALLOC_INFO mem_info;
+ VkMemoryAllocInfo mem_info;
VK_GPU_MEMORY event_mem;
ASSERT_NE(0, mem_req.size) << "vkGetObjectInfo (Event): Failed - expect events to require memory";
@@ -371,9 +371,9 @@
// VK_RESULT VKAPI vkAllocMemory(
// VK_DEVICE device,
- // const VK_MEMORY_ALLOC_INFO* pAllocInfo,
+ // const VkMemoryAllocInfo* pAllocInfo,
// VK_GPU_MEMORY* pMem);
- VK_MEMORY_ALLOC_INFO mem_info;
+ VkMemoryAllocInfo mem_info;
VK_GPU_MEMORY query_mem;
memset(&mem_info, 0, sizeof(mem_info));
@@ -638,7 +638,7 @@
subresource.mipLevel++;
}
- VK_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
+ VkMemoryAllocImageInfo img_alloc = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
.pNext = NULL,
@@ -661,9 +661,9 @@
img_alloc.samples = img_reqs.samples;
// VK_RESULT VKAPI vkAllocMemory(
// VK_DEVICE device,
- // const VK_MEMORY_ALLOC_INFO* pAllocInfo,
+ // const VkMemoryAllocInfo* pAllocInfo,
// VK_GPU_MEMORY* pMem);
- VK_MEMORY_ALLOC_INFO mem_info = {};
+ VkMemoryAllocInfo mem_info = {};
VK_GPU_MEMORY image_mem;
mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
diff --git a/tests/test_environment.cpp b/tests/test_environment.cpp
index 5d3a580..d2a22ef 100644
--- a/tests/test_environment.cpp
+++ b/tests/test_environment.cpp
@@ -51,7 +51,7 @@
uint32_t count;
VK_RESULT err;
- VK_INSTANCE_CREATE_INFO inst_info = {};
+ VkInstanceCreateInfo inst_info = {};
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.pAppInfo = &app_;
@@ -82,7 +82,7 @@
const xcb_setup_t *setup;
xcb_screen_iterator_t iter;
int scr;
- VK_INSTANCE_CREATE_INFO instInfo = {};
+ VkInstanceCreateInfo instInfo = {};
instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instInfo.pNext = NULL;
instInfo.pAppInfo = &app_;
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 9d38aa2..a130f13 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -59,7 +59,7 @@
void VkRenderFramework::InitFramework()
{
VK_RESULT err;
- VK_INSTANCE_CREATE_INFO instInfo = {};
+ VkInstanceCreateInfo instInfo = {};
instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instInfo.pNext = NULL;
instInfo.pAppInfo = &app_info;
@@ -765,7 +765,7 @@
unmap();
// set up the buffer view for the constant buffer
- VK_BUFFER_VIEW_CREATE_INFO view_info = {};
+ VkBufferViewCreateInfo view_info = {};
view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
view_info.buffer = obj();
view_info.viewType = VK_BUFFER_VIEW_RAW;
@@ -896,7 +896,7 @@
unmap();
// set up the buffer view for the constant buffer
- VK_BUFFER_VIEW_CREATE_INFO view_info = {};
+ VkBufferViewCreateInfo view_info = {};
view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
view_info.buffer = obj();
view_info.viewType = VK_BUFFER_VIEW_TYPED;
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index fcadfd9..2f525dc 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -267,15 +267,15 @@
const std::vector<VK_MEMORY_REQUIREMENTS> mem_reqs = memory_requirements();
std::vector<VK_IMAGE_MEMORY_REQUIREMENTS> img_reqs;
std::vector<VK_BUFFER_MEMORY_REQUIREMENTS> buf_reqs;
- VK_MEMORY_ALLOC_IMAGE_INFO img_info;
- VK_MEMORY_ALLOC_BUFFER_INFO buf_info;
- VK_MEMORY_ALLOC_INFO info, *next_info = NULL;
+ VkMemoryAllocImageInfo img_info;
+ VkMemoryAllocBufferInfo buf_info;
+ VkMemoryAllocInfo info, *next_info = NULL;
if (for_img) {
img_reqs = get_info<VK_IMAGE_MEMORY_REQUIREMENTS>(obj(),
VK_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, 0);
EXPECT(img_reqs.size() == 1);
- next_info = (VK_MEMORY_ALLOC_INFO *) &img_info;
+ next_info = (VkMemoryAllocInfo *) &img_info;
img_info.pNext = NULL;
img_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO;
img_info.usage = img_reqs[0].usage;
@@ -290,7 +290,7 @@
if (for_img)
img_info.pNext = &buf_info;
else
- next_info = (VK_MEMORY_ALLOC_INFO *) &buf_info;
+ next_info = (VkMemoryAllocInfo *) &buf_info;
buf_info.pNext = NULL;
buf_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO;
buf_info.usage = buf_reqs[0].usage;
@@ -368,10 +368,10 @@
{
// request all queues
const std::vector<VK_PHYSICAL_GPU_QUEUE_PROPERTIES> queue_props = gpu_.queue_properties();
- std::vector<VK_DEVICE_QUEUE_CREATE_INFO> queue_info;
+ std::vector<VkDeviceQueueCreateInfo> queue_info;
queue_info.reserve(queue_props.size());
for (int i = 0; i < queue_props.size(); i++) {
- VK_DEVICE_QUEUE_CREATE_INFO qi = {};
+ VkDeviceQueueCreateInfo qi = {};
qi.queueNodeIndex = i;
qi.queueCount = queue_props[i].queueCount;
if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
@@ -380,7 +380,7 @@
queue_info.push_back(qi);
}
- VK_LAYER_CREATE_INFO layer_info = {};
+ VkLayerCreateInfo layer_info = {};
layer_info.sType = VK_STRUCTURE_TYPE_LAYER_CREATE_INFO;
std::vector<const char *> layers;
@@ -394,7 +394,7 @@
const std::vector<const char *> exts = gpu_.extensions();
- VK_DEVICE_CREATE_INFO dev_info = {};
+ VkDeviceCreateInfo dev_info = {};
dev_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
dev_info.pNext = (enable_layers) ? static_cast<void *>(&layer_info) : NULL;
dev_info.queueRecordCount = queue_info.size();
@@ -407,7 +407,7 @@
init(dev_info);
}
-void Device::init(const VK_DEVICE_CREATE_INFO &info)
+void Device::init(const VkDeviceCreateInfo &info)
{
DERIVED_OBJECT_INIT(vkCreateDevice, gpu_.obj(), &info);
@@ -565,7 +565,7 @@
EXPECT(vkFreeMemory(obj()) == VK_SUCCESS);
}
-void GpuMemory::init(const Device &dev, const VK_MEMORY_ALLOC_INFO &info)
+void GpuMemory::init(const Device &dev, const VkMemoryAllocInfo &info)
{
DERIVED_OBJECT_INIT(vkAllocMemory, dev.obj(), &info);
}
@@ -666,19 +666,19 @@
return err;
}
-void Buffer::init(const Device &dev, const VK_BUFFER_CREATE_INFO &info)
+void Buffer::init(const Device &dev, const VkBufferCreateInfo &info)
{
init_no_mem(dev, info);
alloc_memory(dev, true, false);
}
-void Buffer::init_no_mem(const Device &dev, const VK_BUFFER_CREATE_INFO &info)
+void Buffer::init_no_mem(const Device &dev, const VkBufferCreateInfo &info)
{
DERIVED_OBJECT_INIT(vkCreateBuffer, dev.obj(), &info);
create_info_ = info;
}
-void BufferView::init(const Device &dev, const VK_BUFFER_VIEW_CREATE_INFO &info)
+void BufferView::init(const Device &dev, const VkBufferViewCreateInfo &info)
{
DERIVED_OBJECT_INIT(vkCreateBufferView, dev.obj(), &info);
alloc_memory(dev);
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 4068e75..39159eb 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -200,7 +200,7 @@
~Device();
// vkCreateDevice()
- void init(const VK_DEVICE_CREATE_INFO &info);
+ void init(const VkDeviceCreateInfo &info);
void init(bool enable_layers); // all queues, all extensions, etc
void init() { init(false); };
@@ -278,7 +278,7 @@
~GpuMemory();
// vkAllocMemory()
- void init(const Device &dev, const VK_MEMORY_ALLOC_INFO &info);
+ void init(const Device &dev, const VkMemoryAllocInfo &info);
// vkPinSystemMemory()
void init(const Device &dev, size_t size, const void *data);
// vkOpenSharedMemory()
@@ -300,8 +300,8 @@
// vkUnmapMemory()
void unmap() const;
- static VK_MEMORY_ALLOC_INFO alloc_info(const VK_MEMORY_REQUIREMENTS &reqs,
- const VK_MEMORY_ALLOC_INFO *next_info);
+ static VkMemoryAllocInfo alloc_info(const VK_MEMORY_REQUIREMENTS &reqs,
+ const VkMemoryAllocInfo *next_info);
};
class Fence : public DerivedObject<VK_FENCE, Object> {
@@ -355,15 +355,15 @@
class Buffer : public DerivedObject<VK_BUFFER, Object> {
public:
explicit Buffer() {}
- explicit Buffer(const Device &dev, const VK_BUFFER_CREATE_INFO &info) { init(dev, info); }
+ explicit Buffer(const Device &dev, const VkBufferCreateInfo &info) { init(dev, info); }
explicit Buffer(const Device &dev, VK_GPU_SIZE size) { init(dev, size); }
// vkCreateBuffer()
- void init(const Device &dev, const VK_BUFFER_CREATE_INFO &info);
+ void init(const Device &dev, const VkBufferCreateInfo &info);
void init(const Device &dev, VK_GPU_SIZE size) { init(dev, create_info(size, 0)); }
- void init_no_mem(const Device &dev, const VK_BUFFER_CREATE_INFO &info);
+ void init_no_mem(const Device &dev, const VkBufferCreateInfo &info);
- static VK_BUFFER_CREATE_INFO create_info(VK_GPU_SIZE size, VK_FLAGS usage);
+ static VkBufferCreateInfo create_info(VK_GPU_SIZE size, VK_FLAGS usage);
VK_BUFFER_MEMORY_BARRIER buffer_memory_barrier(VK_FLAGS output_mask, VK_FLAGS input_mask,
VK_GPU_SIZE offset, VK_GPU_SIZE size) const
@@ -378,13 +378,13 @@
return barrier;
}
private:
- VK_BUFFER_CREATE_INFO create_info_;
+ VkBufferCreateInfo create_info_;
};
class BufferView : public DerivedObject<VK_BUFFER_VIEW, Object> {
public:
// vkCreateBufferView()
- void init(const Device &dev, const VK_BUFFER_VIEW_CREATE_INFO &info);
+ void init(const Device &dev, const VkBufferViewCreateInfo &info);
};
class Image : public DerivedObject<VK_IMAGE, Object> {
@@ -618,10 +618,10 @@
primary_mem_->unmap();
}
-inline VK_MEMORY_ALLOC_INFO GpuMemory::alloc_info(const VK_MEMORY_REQUIREMENTS &reqs,
- const VK_MEMORY_ALLOC_INFO *next_info)
+inline VkMemoryAllocInfo GpuMemory::alloc_info(const VK_MEMORY_REQUIREMENTS &reqs,
+ const VkMemoryAllocInfo *next_info)
{
- VK_MEMORY_ALLOC_INFO info = {};
+ VkMemoryAllocInfo info = {};
info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
if (next_info != NULL)
info.pNext = (void *) next_info;
@@ -633,9 +633,9 @@
return info;
}
-inline VK_BUFFER_CREATE_INFO Buffer::create_info(VK_GPU_SIZE size, VK_FLAGS usage)
+inline VkBufferCreateInfo Buffer::create_info(VK_GPU_SIZE size, VK_FLAGS usage)
{
- VK_BUFFER_CREATE_INFO info = {};
+ VkBufferCreateInfo info = {};
info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
info.size = size;
info.usage = usage;
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 2cfa002..ec8a97c 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -104,7 +104,7 @@
def _get_printf_params(self, vk_type, name, output_param, cpp=False):
# TODO : Need ENUM and STRUCT checks here
if vk_helper.is_type(vk_type, 'enum'):#"_TYPE" in vk_type: # TODO : This should be generic ENUM check
- return ("%s", "string_%s(%s)" % (vk_type.strip('const ').strip('*'), name))
+ return ("%s", "string_%s(%s)" % (vk_type.replace('const ', '').strip('*'), name))
if "char*" == vk_type:
return ("%s", name)
if "uint64" in vk_type:
@@ -636,11 +636,11 @@
log_func_no_addr += '%s = address, ' % (p.name)
else:
log_func_no_addr += '%s = " << %s << ", ' % (p.name, pfi)
- if prev_count_name != '' and (prev_count_name.strip('Count')[1:] in p.name or 'slotCount' == prev_count_name):
+ if prev_count_name != '' and (prev_count_name.replace('Count', '')[1:] in p.name or 'slotCount' == prev_count_name):
sp_param_dict[pindex] = prev_count_name
elif 'pDescriptorSets' == p.name and proto.params[-1].name == 'pCount':
sp_param_dict[pindex] = '*pCount'
- elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').strip('const '), 'struct'):
+ elif 'Wsi' not in proto.name and vk_helper.is_type(p.ty.strip('*').replace('const ', ''), 'struct'):
sp_param_dict[pindex] = 'index'
pindex += 1
if p.name.endswith('Count'):
@@ -666,7 +666,7 @@
log_func += '\n string tmp_str;'
for sp_index in sp_param_dict:
if 'index' == sp_param_dict[sp_index]:
- cis_print_func = 'vk_print_%s' % (proto.params[sp_index].ty.strip('const ').strip('*').lower())
+ cis_print_func = 'vk_print_%s' % (proto.params[sp_index].ty.replace('const ', '').strip('*').lower())
local_name = proto.params[sp_index].name
if '*' not in proto.params[sp_index].ty:
local_name = '&%s' % proto.params[sp_index].name
@@ -677,11 +677,9 @@
else: # We have a count value stored to iterate over an array
print_cast = ''
print_func = ''
- if vk_helper.is_type(proto.params[sp_index].ty.strip('*').strip('const '), 'struct'):
+ if vk_helper.is_type(proto.params[sp_index].ty.strip('*').replace('const ', ''), 'struct'):
print_cast = '&'
- print_func = 'vk_print_%s' % proto.params[sp_index].ty.strip('const ').strip('*').lower()
- #cis_print_func = 'tmp_str = vk_print_%s(&%s[i], " ");' % (proto.params[sp_index].ty.strip('const ').strip('*').lower(), proto.params[sp_index].name)
-# TODO : Need to display this address as a string
+ print_func = 'vk_print_%s' % proto.params[sp_index].ty.replace('const ', '').strip('*').lower()
else:
print_cast = ''
print_func = 'string_convert_helper'
@@ -1084,7 +1082,7 @@
decl = proto.c_func(prefix="vk", attr="VKAPI")
param0_name = proto.params[0].name
- p0_type = proto.params[0].ty.strip('*').strip('const ')
+ p0_type = proto.params[0].ty.strip('*').replace('const ', '')
create_line = ''
destroy_line = ''
funcs = []
@@ -1124,13 +1122,13 @@
create_line += ' }\n'
elif 'CreatePresentableImage' in proto.name:
create_line = ' loader_platform_thread_lock_mutex(&objLock);\n'
- create_line += ' ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-2].name, obj_type_mapping[proto.params[-2].ty.strip('*').strip('const ')])
+ create_line += ' ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-2].name, obj_type_mapping[proto.params[-2].ty.strip('*').replace('const ', '')])
create_line += ' ll_insert_obj((void*)*pMem, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n'
- # create_line += ' ll_insert_obj((void*)*%s, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n' % (obj_type_mapping[proto.params[-1].ty.strip('*').strip('const ')])
+ # create_line += ' ll_insert_obj((void*)*%s, VK_OBJECT_TYPE_PRESENTABLE_IMAGE_MEMORY);\n' % (obj_type_mapping[proto.params[-1].ty.strip('*').replace('const ', '')])
create_line += ' loader_platform_thread_unlock_mutex(&objLock);\n'
elif 'Create' in proto.name or 'Alloc' in proto.name:
create_line = ' loader_platform_thread_lock_mutex(&objLock);\n'
- create_line += ' ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-1].name, obj_type_mapping[proto.params[-1].ty.strip('*').strip('const ')])
+ create_line += ' ll_insert_obj((void*)*%s, %s);\n' % (proto.params[-1].name, obj_type_mapping[proto.params[-1].ty.strip('*').replace('const ', '')])
create_line += ' loader_platform_thread_unlock_mutex(&objLock);\n'
if 'DestroyObject' in proto.name:
destroy_line = ' loader_platform_thread_lock_mutex(&objLock);\n'
diff --git a/vk_helper.py b/vk_helper.py
index 74ae5d9..f8cf2a8 100755
--- a/vk_helper.py
+++ b/vk_helper.py
@@ -160,6 +160,7 @@
(cur_char, targ_type) = line.strip().split(None, 1)
self.typedef_fwd_dict[base_type] = targ_type.strip(';')
self.typedef_rev_dict[targ_type.strip(';')] = base_type
+ #print("fwd_dict: %s = %s" % (base_type, targ_type))
elif parse_enum:
#if 'VK_MAX_ENUM' not in line and '{' not in line:
if True not in [ens in line for ens in ['{', 'VK_MAX_ENUM', '_RANGE']]:
@@ -238,7 +239,7 @@
self.struct_dict[struct_type][num]['ptr'] = False
if 'const' in member_type:
self.struct_dict[struct_type][num]['const'] = True
- member_type = member_type.strip('const').strip()
+ member_type = member_type.replace('const', '').strip()
else:
self.struct_dict[struct_type][num]['const'] = False
# TODO : There is a bug here where it seems that at the time we do this check,
@@ -296,6 +297,29 @@
sys.stdout.write(typedef_fwd_dict[struct_name])
sys.stdout.write(";\n\n")
+#
+def get_struct_name_from_struct_type(struct_type):
+ caps_struct_name = struct_type.replace("_STRUCTURE_TYPE", "")
+ # NOTE: These must stay in caps as they are looking at the VK_STRUCTURE_TYPE_*_CREATE_INFO
+ # and that has not changed to camel case
+ exceptions_list = ['VK_DEVICE_CREATE_INFO', 'VK_INSTANCE_CREATE_INFO', 'VK_LAYER_CREATE_INFO',
+ 'VK_MEMORY_ALLOC_INFO', 'VK_MEMORY_ALLOC_BUFFER_INFO', 'VK_MEMORY_ALLOC_IMAGE_INFO',
+ 'VK_BUFFER_CREATE_INFO', 'VK_BUFFER_VIEW_CREATE_INFO']
+ if caps_struct_name in exceptions_list:
+ char_idx = 0
+ struct_name = ''
+ for char in caps_struct_name:
+ if (0 == char_idx) or (caps_struct_name[char_idx-1] == '_'):
+ struct_name += caps_struct_name[char_idx]
+ elif (caps_struct_name[char_idx] == '_'):
+ pass
+ else:
+ struct_name += caps_struct_name[char_idx].lower()
+ char_idx += 1
+ else:
+ struct_name = caps_struct_name
+ return struct_name
+
# class for writing common file elements
# Here's how this class lays out a file:
# COPYRIGHT
@@ -508,7 +532,7 @@
class_num = 0
if "_STRUCTURE_TYPE" in e:
for v in sorted(enum_type_dict[e]):
- struct_name = v.replace("_STRUCTURE_TYPE", "")
+ struct_name = get_struct_name_from_struct_type(v)
class_name = self.get_class_name(struct_name)
instance_name = "swc%i" % class_num
dp_funcs.append(" case %s:\n {" % (v))
@@ -705,7 +729,7 @@
for e in enum_type_dict:
if "_STRUCTURE_TYPE" in e:
for v in sorted(enum_type_dict[e]):
- struct_name = v.replace("_STRUCTURE_TYPE", "")
+ struct_name = get_struct_name_from_struct_type(v)
print_func_name = self._get_sh_func_name(struct_name)
sh_funcs.append(' case %s:\n {' % (v))
sh_funcs.append(' return %s((%s*)pStruct, indent);' % (print_func_name, struct_name))
@@ -754,12 +778,16 @@
if 1 < stp_list[index]['full_type'].count('*'):
addr_char = ''
if (stp_list[index]['array']):
+ sh_funcs.append('/* A */');
if stp_list[index]['dyn_array']:
+ sh_funcs.append('/* AA */');
array_count = 'pStruct->%s' % (stp_list[index]['array_size'])
else:
+ sh_funcs.append('/* AB */');
array_count = '%s' % (stp_list[index]['array_size'])
sh_funcs.append('%sstp_strs[%u] = "";' % (indent, index))
if not idx_ss_decl:
+ sh_funcs.append('/* AC */');
sh_funcs.append('%sstringstream index_ss;' % (indent))
idx_ss_decl = True
sh_funcs.append('%sif (pStruct->%s) {' % (indent, stp_list[index]['name']))
@@ -769,15 +797,19 @@
sh_funcs.append('%sindex_ss.str("");' % (indent))
sh_funcs.append('%sindex_ss << i;' % (indent))
if not is_type(stp_list[index]['type'], 'struct'):
+ sh_funcs.append('/* AD */');
addr_char = ''
sh_funcs.append('%sss[%u] << %spStruct->%s[i];' % (indent, index, addr_char, stp_list[index]['name']))
sh_funcs.append('%sstp_strs[%u] += " " + prefix + "%s[" + index_ss.str() + "] = " + ss[%u].str() + "\\n";' % (indent, index, stp_list[index]['name'], index))
else:
+ sh_funcs.append('/* AD */');
sh_funcs.append('%sss[%u] << %spStruct->%s[i];' % (indent, index, addr_char, stp_list[index]['name']))
sh_funcs.append('%stmp_str = %s(%spStruct->%s[i], extra_indent);' % (indent, self._get_sh_func_name(stp_list[index]['type']), addr_char, stp_list[index]['name']))
if self.no_addr:
+ sh_funcs.append('/* ADA */');
sh_funcs.append('%sstp_strs[%u] += " " + prefix + "%s[" + index_ss.str() + "] (addr)\\n" + tmp_str;' % (indent, index, stp_list[index]['name']))
else:
+ sh_funcs.append('/* ADB */');
sh_funcs.append('%sstp_strs[%u] += " " + prefix + "%s[" + index_ss.str() + "] (" + ss[%u].str() + ")\\n" + tmp_str;' % (indent, index, stp_list[index]['name'], index))
indent = indent[4:]
sh_funcs.append('%s}' % (indent))
@@ -785,6 +817,7 @@
indent = indent[4:]
sh_funcs.append('%s}' % (indent))
elif (stp_list[index]['ptr']):
+ sh_funcs.append('/* B */');
sh_funcs.append(' if (pStruct->%s) {' % stp_list[index]['name'])
if 'pNext' == stp_list[index]['name']:
sh_funcs.append(' tmp_str = dynamic_display((void*)pStruct->pNext, prefix);')
@@ -804,6 +837,7 @@
sh_funcs.append(' else')
sh_funcs.append(' stp_strs[%u] = "";' % index)
else:
+ sh_funcs.append('/* C */');
sh_funcs.append(' tmp_str = %s(&pStruct->%s, extra_indent);' % (self._get_sh_func_name(stp_list[index]['type']), stp_list[index]['name']))
sh_funcs.append(' ss[%u] << %spStruct->%s;' % (index, addr_char, stp_list[index]['name']))
if self.no_addr:
@@ -865,7 +899,7 @@
for e in enum_type_dict:
if "_STRUCTURE_TYPE" in e:
for v in sorted(enum_type_dict[e]):
- struct_name = v.replace("_STRUCTURE_TYPE", "")
+ struct_name = get_struct_name_from_struct_type(v)
print_func_name = self._get_sh_func_name(struct_name)
sh_funcs.append(' case %s:\n {' % (v))
sh_funcs.append(' return %s((%s*)pStruct, indent);' % (print_func_name, struct_name))
@@ -1131,7 +1165,7 @@
for e in enum_type_dict:
if '_STRUCTURE_TYPE' in e:
for v in sorted(enum_type_dict[e]):
- struct_name = v.replace("_STRUCTURE_TYPE", "")
+ struct_name = get_struct_name_from_struct_type(v)
sh_funcs.append('%scase %s:' % (indent, v))
sh_funcs.append('%s{' % (indent))
indent += ' '
@@ -1533,7 +1567,7 @@
for e in enum_type_dict:
if "_STRUCTURE_TYPE" in e:
for v in sorted(enum_type_dict[e]):
- struct_name = v.replace("_STRUCTURE_TYPE", "")
+ struct_name = get_struct_name_from_struct_type(v)
print_func_name = self._get_gv_func_name(struct_name)
# TODO : Hand-coded fixes for some exceptions
#if 'VK_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
diff --git a/vulkan.py b/vulkan.py
index 6e30e45..28fcd7c 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -218,7 +218,7 @@
],
protos=[
Proto("VK_RESULT", "CreateInstance",
- [Param("const VK_INSTANCE_CREATE_INFO*", "pCreateInfo"),
+ [Param("const VkInstanceCreateInfo*", "pCreateInfo"),
Param("VK_INSTANCE*", "pInstance")]),
Proto("VK_RESULT", "DestroyInstance",
@@ -242,7 +242,7 @@
Proto("VK_RESULT", "CreateDevice",
[Param("VK_PHYSICAL_GPU", "gpu"),
- Param("const VK_DEVICE_CREATE_INFO*", "pCreateInfo"),
+ Param("const VkDeviceCreateInfo*", "pCreateInfo"),
Param("VK_DEVICE*", "pDevice")]),
Proto("VK_RESULT", "DestroyDevice",
@@ -288,7 +288,7 @@
Proto("VK_RESULT", "AllocMemory",
[Param("VK_DEVICE", "device"),
- Param("const VK_MEMORY_ALLOC_INFO*", "pAllocInfo"),
+ Param("const VkMemoryAllocInfo*", "pAllocInfo"),
Param("VK_GPU_MEMORY*", "pMem")]),
Proto("VK_RESULT", "FreeMemory",
@@ -436,12 +436,12 @@
Proto("VK_RESULT", "CreateBuffer",
[Param("VK_DEVICE", "device"),
- Param("const VK_BUFFER_CREATE_INFO*", "pCreateInfo"),
+ Param("const VkBufferCreateInfo*", "pCreateInfo"),
Param("VK_BUFFER*", "pBuffer")]),
Proto("VK_RESULT", "CreateBufferView",
[Param("VK_DEVICE", "device"),
- Param("const VK_BUFFER_VIEW_CREATE_INFO*", "pCreateInfo"),
+ Param("const VkBufferViewCreateInfo*", "pCreateInfo"),
Param("VK_BUFFER_VIEW*", "pView")]),
Proto("VK_RESULT", "CreateImage",