From 78351a69dfc6e3aca0490c4de282dc84d66db382 Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Fri, 10 Apr 2015 08:34:15 -0600 Subject: vulkan: beautification changes TODO: verify vk-layer-generate.py TODO: need to rename object tracker generator v2: fix "python3 vulkan.py" fix dead cod in tri introduced by rebase beautify wsi_null.c (olv) --- layers/basic.cpp | 36 +-- layers/draw_state.cpp | 694 +++++++++++++++++++++++------------------------ layers/draw_state.h | 106 ++++---- layers/glave_snapshot.c | 424 ++++++++++++++--------------- layers/glave_snapshot.h | 14 +- layers/layers_msg.h | 4 +- layers/mem_tracker.cpp | 526 +++++++++++++++++------------------ layers/mem_tracker.h | 44 +-- layers/multi.cpp | 62 ++--- layers/object_track.h | 4 +- layers/param_checker.cpp | 560 +++++++++++++++++++------------------- 11 files changed, 1237 insertions(+), 1237 deletions(-) (limited to 'layers') diff --git a/layers/basic.cpp b/layers/basic.cpp index 402adb68..9501c13e 100644 --- a/layers/basic.cpp +++ b/layers/basic.cpp @@ -49,21 +49,21 @@ static VK_LAYER_DISPATCH_TABLE * initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw return it->second; } - layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VK_PHYSICAL_GPU) gpuw->nextObject); + layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VkPhysicalGpu) gpuw->nextObject); return pTable; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkLayerExtension1(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkLayerExtension1(VkDevice device) { printf("In vkLayerExtension1() call w/ device: %p\n", (void*)device); printf("vkLayerExtension1 returning SUCCESS\n"); return VK_SUCCESS; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { - VK_RESULT result; + VkResult result; VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */ @@ -77,7 +77,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const { printf("At start of wrapped vkGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu); VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw]; - result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + result = pTable->GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); printf("Completed wrapped vkGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu); } else { @@ -86,29 +86,29 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw]; printf("At start of wrapped vkCreateDevice() call w/ gpu: %p\n", (void*)gpu); - VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = pTable->CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); // create a mapping for the device object into the dispatch table tableMap.emplace(*pDevice, pTable); printf("Completed wrapped vkCreateDevice() call w/ pDevice, Device %p: %p\n", (void*)pDevice, (void *) *pDevice); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetFormatInfo(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap[device]; printf("At start of wrapped vkGetFormatInfo() call w/ device: %p\n", (void*)device); - VK_RESULT result = pTable->GetFormatInfo(device, format, infoType, pDataSize, pData); + VkResult result = pTable->GetFormatInfo(device, format, infoType, pDataSize, pData); printf("Completed wrapped vkGetFormatInfo() call w/ device: %p\n", (void*)device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { if (gpu != NULL) { @@ -116,7 +116,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma VK_LAYER_DISPATCH_TABLE* pTable = initLayerTable(gpuw); printf("At start of wrapped vkEnumerateLayers() call w/ gpu: %p\n", gpu); - VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = pTable->EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); return result; } else { @@ -125,11 +125,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma // Example of a layer that is only compatible with Intel's GPUs VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT*) pReserved; - vkGetGpuInfoType fpGetGpuInfo; - VK_PHYSICAL_GPU_PROPERTIES gpuProps; - size_t dataSize = sizeof(VK_PHYSICAL_GPU_PROPERTIES); - fpGetGpuInfo = (vkGetGpuInfoType) gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, "vkGetGpuInfo"); - fpGetGpuInfo((VK_PHYSICAL_GPU) gpuw->nextObject, VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &dataSize, &gpuProps); + PFN_vkGetGpuInfo fpGetGpuInfo; + VkPhysicalGpuProperties gpuProps; + size_t dataSize = sizeof(VkPhysicalGpuProperties); + fpGetGpuInfo = (PFN_vkGetGpuInfo) gpuw->pGPA((VkPhysicalGpu) gpuw->nextObject, "vkGetGpuInfo"); + fpGetGpuInfo((VkPhysicalGpu) gpuw->nextObject, VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &dataSize, &gpuProps); if (gpuProps.vendorId == 0x8086) { *pOutLayerCount = 1; @@ -142,7 +142,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma } } -VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName) +VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* pName) { if (gpu == NULL) return NULL; @@ -165,6 +165,6 @@ VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* pNam VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName); + return gpuw->pGPA((VkPhysicalGpu) gpuw->nextObject, pName); } } diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index 5e4a95fe..6ff0fcee 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -41,18 +41,18 @@ #include "loader_platform.h" #include "layers_msg.h" -unordered_map sampleMap; -unordered_map imageMap; -unordered_map bufferMap; -unordered_map dynamicStateMap; -unordered_map pipelineMap; -unordered_map poolMap; -unordered_map setMap; -unordered_map layoutMap; +unordered_map sampleMap; +unordered_map imageMap; +unordered_map bufferMap; +unordered_map dynamicStateMap; +unordered_map pipelineMap; +unordered_map poolMap; +unordered_map setMap; +unordered_map layoutMap; // Map for layout chains -unordered_map cmdBufferMap; -unordered_map renderPassMap; -unordered_map frameBufferMap; +unordered_map cmdBufferMap; +unordered_map renderPassMap; +unordered_map frameBufferMap; static VK_LAYER_DISPATCH_TABLE nextTable; static VK_BASE_LAYER_OBJECT *pCurObj; @@ -176,7 +176,7 @@ static uint64_t g_drawCount[NUM_DRAW_TYPES] = {0, 0, 0, 0}; // Then need to synchronize the accesses based on cmd buffer so that if I'm reading state on one cmd buffer, updates // to that same cmd buffer by separate thread are not changing state from underneath us // Track the last cmd buffer touched by this thread -static VK_CMD_BUFFER g_lastCmdBuffer[MAX_TID] = {NULL}; +static VkCmdBuffer g_lastCmdBuffer[MAX_TID] = {NULL}; // Track the last group of CBs touched for displaying to dot file static GLOBAL_CB_NODE* g_pLastTouchedCB[NUM_COMMAND_BUFFERS_TO_DISPLAY] = {NULL}; static uint32_t g_lastTouchedCBIndex = 0; @@ -184,14 +184,14 @@ static uint32_t g_lastTouchedCBIndex = 0; static GLOBAL_CB_NODE* g_lastGlobalCB = NULL; static PIPELINE_NODE* g_lastBoundPipeline = NULL; static DYNAMIC_STATE_NODE* g_lastBoundDynamicState[VK_NUM_STATE_BIND_POINT] = {NULL}; -static VK_DESCRIPTOR_SET g_lastBoundDescriptorSet = NULL; +static VkDescriptorSet g_lastBoundDescriptorSet = NULL; #define MAX_BINDING 0xFFFFFFFF // Default vtxBinding value in CB Node to identify if no vtxBinding set //static DYNAMIC_STATE_NODE* g_pDynamicStateHead[VK_NUM_STATE_BIND_POINT] = {0}; -static void insertDynamicState(const VK_DYNAMIC_STATE_OBJECT state, const GENERIC_HEADER* pCreateInfo, VK_STATE_BIND_POINT bindPoint) +static void insertDynamicState(const VkDynamicStateObject state, const GENERIC_HEADER* pCreateInfo, VkStateBindPoint bindPoint) { - VK_DYNAMIC_VP_STATE_CREATE_INFO* pVPCI = NULL; + VkDynamicVpStateCreateInfo* pVPCI = NULL; size_t scSize = 0; size_t vpSize = 0; loader_platform_thread_lock_mutex(&globalLock); @@ -199,23 +199,23 @@ static void insertDynamicState(const VK_DYNAMIC_STATE_OBJECT state, const GENERI pStateNode->stateObj = state; switch (pCreateInfo->sType) { case VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO: - memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_VP_STATE_CREATE_INFO)); - pVPCI = (VK_DYNAMIC_VP_STATE_CREATE_INFO*)pCreateInfo; - pStateNode->create_info.vpci.pScissors = new VK_RECT[pStateNode->create_info.vpci.viewportAndScissorCount]; - pStateNode->create_info.vpci.pViewports = new VK_VIEWPORT[pStateNode->create_info.vpci.viewportAndScissorCount]; - scSize = pVPCI->viewportAndScissorCount * sizeof(VK_RECT); - vpSize = pVPCI->viewportAndScissorCount * sizeof(VK_VIEWPORT); + memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicVpStateCreateInfo)); + pVPCI = (VkDynamicVpStateCreateInfo*)pCreateInfo; + pStateNode->create_info.vpci.pScissors = new VkRect[pStateNode->create_info.vpci.viewportAndScissorCount]; + pStateNode->create_info.vpci.pViewports = new VkViewport[pStateNode->create_info.vpci.viewportAndScissorCount]; + scSize = pVPCI->viewportAndScissorCount * sizeof(VkRect); + vpSize = pVPCI->viewportAndScissorCount * sizeof(VkViewport); memcpy((void*)pStateNode->create_info.vpci.pScissors, pVPCI->pScissors, scSize); memcpy((void*)pStateNode->create_info.vpci.pViewports, pVPCI->pViewports, vpSize); break; case VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO: - memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_RS_STATE_CREATE_INFO)); + memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicRsStateCreateInfo)); break; case VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO: - memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_CB_STATE_CREATE_INFO)); + memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicCbStateCreateInfo)); break; case VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO: - memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VK_DYNAMIC_DS_STATE_CREATE_INFO)); + memcpy(&pStateNode->create_info, pCreateInfo, sizeof(VkDynamicDsStateCreateInfo)); break; default: assert(0); @@ -228,7 +228,7 @@ static void insertDynamicState(const VK_DYNAMIC_STATE_OBJECT state, const GENERI // Free all allocated nodes for Dynamic State objs static void deleteDynamicState() { - for (unordered_map::iterator ii=dynamicStateMap.begin(); ii!=dynamicStateMap.end(); ++ii) { + for (unordered_map::iterator ii=dynamicStateMap.begin(); ii!=dynamicStateMap.end(); ++ii) { if (VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO == (*ii).second->create_info.vpci.sType) { delete[] (*ii).second->create_info.vpci.pScissors; delete[] (*ii).second->create_info.vpci.pViewports; @@ -239,11 +239,11 @@ static void deleteDynamicState() // Free all sampler nodes static void deleteSamplers() { - for (unordered_map::iterator ii=sampleMap.begin(); ii!=sampleMap.end(); ++ii) { + for (unordered_map::iterator ii=sampleMap.begin(); ii!=sampleMap.end(); ++ii) { delete (*ii).second; } } -static VK_IMAGE_VIEW_CREATE_INFO* getImageViewCreateInfo(VK_IMAGE_VIEW view) +static VkImageViewCreateInfo* getImageViewCreateInfo(VkImageView view) { loader_platform_thread_lock_mutex(&globalLock); if (imageMap.find(view) == imageMap.end()) { @@ -258,11 +258,11 @@ static VK_IMAGE_VIEW_CREATE_INFO* getImageViewCreateInfo(VK_IMAGE_VIEW view) // Free all image nodes static void deleteImages() { - for (unordered_map::iterator ii=imageMap.begin(); ii!=imageMap.end(); ++ii) { + for (unordered_map::iterator ii=imageMap.begin(); ii!=imageMap.end(); ++ii) { delete (*ii).second; } } -static VkBufferViewCreateInfo* getBufferViewCreateInfo(VK_BUFFER_VIEW view) +static VkBufferViewCreateInfo* getBufferViewCreateInfo(VkBufferView view) { loader_platform_thread_lock_mutex(&globalLock); if (bufferMap.find(view) == bufferMap.end()) { @@ -277,13 +277,13 @@ static VkBufferViewCreateInfo* getBufferViewCreateInfo(VK_BUFFER_VIEW view) // Free all buffer nodes static void deleteBuffers() { - for (unordered_map::iterator ii=bufferMap.begin(); ii!=bufferMap.end(); ++ii) { + for (unordered_map::iterator ii=bufferMap.begin(); ii!=bufferMap.end(); ++ii) { delete (*ii).second; } } -static GLOBAL_CB_NODE* getCBNode(VK_CMD_BUFFER cb); +static GLOBAL_CB_NODE* getCBNode(VkCmdBuffer cb); -static void updateCBTracking(VK_CMD_BUFFER cb) +static void updateCBTracking(VkCmdBuffer cb) { g_lastCmdBuffer[getTIDIndex()] = cb; GLOBAL_CB_NODE* pCB = getCBNode(cb); @@ -302,7 +302,7 @@ static void updateCBTracking(VK_CMD_BUFFER cb) } // Print the last bound dynamic state -static void printDynamicState(const VK_CMD_BUFFER cb) +static void printDynamicState(const VkCmdBuffer cb) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB) { @@ -310,13 +310,13 @@ static void printDynamicState(const VK_CMD_BUFFER cb) char str[4*1024]; for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) { if (pCB->lastBoundDynamicState[i]) { - sprintf(str, "Reporting CreateInfo for currently bound %s object %p", string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i), pCB->lastBoundDynamicState[i]->stateObj); + sprintf(str, "Reporting CreateInfo for currently bound %s object %p", string_VkStateBindPoint((VkStateBindPoint)i), pCB->lastBoundDynamicState[i]->stateObj); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", str); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pCB->lastBoundDynamicState[i]->stateObj, 0, DRAWSTATE_NONE, "DS", dynamic_display(pCB->lastBoundDynamicState[i]->pCreateInfo, " ").c_str()); break; } else { - sprintf(str, "No dynamic state of type %s bound", string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i)); + sprintf(str, "No dynamic state of type %s bound", string_VkStateBindPoint((VkStateBindPoint)i)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", str); } } @@ -329,7 +329,7 @@ static void printDynamicState(const VK_CMD_BUFFER cb) } } // Retrieve pipeline node ptr for given pipeline object -static PIPELINE_NODE* getPipeline(VK_PIPELINE pipeline) +static PIPELINE_NODE* getPipeline(VkPipeline pipeline) { loader_platform_thread_lock_mutex(&globalLock); if (pipelineMap.find(pipeline) == pipelineMap.end()) { @@ -341,7 +341,7 @@ static PIPELINE_NODE* getPipeline(VK_PIPELINE pipeline) } // For given sampler, return a ptr to its Create Info struct, or NULL if sampler not found -static VK_SAMPLER_CREATE_INFO* getSamplerCreateInfo(const VK_SAMPLER sampler) +static VkSamplerCreateInfo* getSamplerCreateInfo(const VkSampler sampler) { loader_platform_thread_lock_mutex(&globalLock); if (sampleMap.find(sampler) == sampleMap.end()) { @@ -354,49 +354,49 @@ static VK_SAMPLER_CREATE_INFO* getSamplerCreateInfo(const VK_SAMPLER sampler) // Init the pipeline mapping info based on pipeline create info LL tree // Threading note : Calls to this function should wrapped in mutex -static void initPipeline(PIPELINE_NODE* pPipeline, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo) +static void initPipeline(PIPELINE_NODE* pPipeline, const VkGraphicsPipelineCreateInfo* pCreateInfo) { // First init create info, we'll shadow the structs as we go down the tree // TODO : Validate that no create info is incorrectly replicated - memcpy(&pPipeline->graphicsPipelineCI, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO)); + memcpy(&pPipeline->graphicsPipelineCI, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo)); GENERIC_HEADER* pTrav = (GENERIC_HEADER*)pCreateInfo->pNext; GENERIC_HEADER* pPrev = (GENERIC_HEADER*)&pPipeline->graphicsPipelineCI; // Hold prev ptr to tie chain of structs together size_t bufferSize = 0; - VK_PIPELINE_VERTEX_INPUT_CREATE_INFO* pVICI = NULL; - VK_PIPELINE_CB_STATE_CREATE_INFO* pCBCI = NULL; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO* pTmpPSSCI = NULL; + VkPipelineVertexInputCreateInfo* pVICI = NULL; + VkPipelineCbStateCreateInfo* pCBCI = NULL; + VkPipelineShaderStageCreateInfo* pTmpPSSCI = NULL; while (pTrav) { switch (pTrav->sType) { case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: - pTmpPSSCI = (VK_PIPELINE_SHADER_STAGE_CREATE_INFO*)pTrav; + pTmpPSSCI = (VkPipelineShaderStageCreateInfo*)pTrav; switch (pTmpPSSCI->shader.stage) { case VK_SHADER_STAGE_VERTEX: pPrev->pNext = &pPipeline->vsCI; pPrev = (GENERIC_HEADER*)&pPipeline->vsCI; - memcpy(&pPipeline->vsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO)); + memcpy(&pPipeline->vsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo)); break; case VK_SHADER_STAGE_TESS_CONTROL: pPrev->pNext = &pPipeline->tcsCI; pPrev = (GENERIC_HEADER*)&pPipeline->tcsCI; - memcpy(&pPipeline->tcsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO)); + memcpy(&pPipeline->tcsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo)); break; case VK_SHADER_STAGE_TESS_EVALUATION: pPrev->pNext = &pPipeline->tesCI; pPrev = (GENERIC_HEADER*)&pPipeline->tesCI; - memcpy(&pPipeline->tesCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO)); + memcpy(&pPipeline->tesCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo)); break; case VK_SHADER_STAGE_GEOMETRY: pPrev->pNext = &pPipeline->gsCI; pPrev = (GENERIC_HEADER*)&pPipeline->gsCI; - memcpy(&pPipeline->gsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO)); + memcpy(&pPipeline->gsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo)); break; case VK_SHADER_STAGE_FRAGMENT: pPrev->pNext = &pPipeline->fsCI; pPrev = (GENERIC_HEADER*)&pPipeline->fsCI; - memcpy(&pPipeline->fsCI, pTmpPSSCI, sizeof(VK_PIPELINE_SHADER_STAGE_CREATE_INFO)); + memcpy(&pPipeline->fsCI, pTmpPSSCI, sizeof(VkPipelineShaderStageCreateInfo)); break; case VK_SHADER_STAGE_COMPUTE: - // TODO : Flag error, CS is specified through VK_COMPUTE_PIPELINE_CREATE_INFO + // TODO : Flag error, CS is specified through VkComputePipelineCreateInfo break; default: // TODO : Flag error @@ -406,64 +406,64 @@ static void initPipeline(PIPELINE_NODE* pPipeline, const VK_GRAPHICS_PIPELINE_CR case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO: pPrev->pNext = &pPipeline->vertexInputCI; pPrev = (GENERIC_HEADER*)&pPipeline->vertexInputCI; - memcpy((void*)&pPipeline->vertexInputCI, pTrav, sizeof(VK_PIPELINE_VERTEX_INPUT_CREATE_INFO)); + memcpy((void*)&pPipeline->vertexInputCI, pTrav, sizeof(VkPipelineVertexInputCreateInfo)); // Copy embedded ptrs - pVICI = (VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav; + pVICI = (VkPipelineVertexInputCreateInfo*)pTrav; pPipeline->vtxBindingCount = pVICI->bindingCount; if (pPipeline->vtxBindingCount) { - pPipeline->pVertexBindingDescriptions = new VK_VERTEX_INPUT_BINDING_DESCRIPTION[pPipeline->vtxBindingCount]; - bufferSize = pPipeline->vtxBindingCount * sizeof(VK_VERTEX_INPUT_BINDING_DESCRIPTION); - memcpy((void*)pPipeline->pVertexBindingDescriptions, ((VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize); + pPipeline->pVertexBindingDescriptions = new VkVertexInputBindingDescription[pPipeline->vtxBindingCount]; + bufferSize = pPipeline->vtxBindingCount * sizeof(VkVertexInputBindingDescription); + memcpy((void*)pPipeline->pVertexBindingDescriptions, ((VkPipelineVertexInputCreateInfo*)pTrav)->pVertexAttributeDescriptions, bufferSize); } pPipeline->vtxAttributeCount = pVICI->attributeCount; if (pPipeline->vtxAttributeCount) { - pPipeline->pVertexAttributeDescriptions = new VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION[pPipeline->vtxAttributeCount]; - bufferSize = pPipeline->vtxAttributeCount * sizeof(VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION); - memcpy((void*)pPipeline->pVertexAttributeDescriptions, ((VK_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pTrav)->pVertexAttributeDescriptions, bufferSize); + pPipeline->pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[pPipeline->vtxAttributeCount]; + bufferSize = pPipeline->vtxAttributeCount * sizeof(VkVertexInputAttributeDescription); + memcpy((void*)pPipeline->pVertexAttributeDescriptions, ((VkPipelineVertexInputCreateInfo*)pTrav)->pVertexAttributeDescriptions, bufferSize); } break; case VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->iaStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->iaStateCI; - memcpy((void*)&pPipeline->iaStateCI, pTrav, sizeof(VK_PIPELINE_IA_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->iaStateCI, pTrav, sizeof(VkPipelineIaStateCreateInfo)); break; case VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->tessStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->tessStateCI; - memcpy((void*)&pPipeline->tessStateCI, pTrav, sizeof(VK_PIPELINE_TESS_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->tessStateCI, pTrav, sizeof(VkPipelineTessStateCreateInfo)); break; case VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->vpStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->vpStateCI; - memcpy((void*)&pPipeline->vpStateCI, pTrav, sizeof(VK_PIPELINE_VP_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->vpStateCI, pTrav, sizeof(VkPipelineVpStateCreateInfo)); break; case VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->rsStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->rsStateCI; - memcpy((void*)&pPipeline->rsStateCI, pTrav, sizeof(VK_PIPELINE_RS_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->rsStateCI, pTrav, sizeof(VkPipelineRsStateCreateInfo)); break; case VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->msStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->msStateCI; - memcpy((void*)&pPipeline->msStateCI, pTrav, sizeof(VK_PIPELINE_MS_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->msStateCI, pTrav, sizeof(VkPipelineMsStateCreateInfo)); break; case VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->cbStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->cbStateCI; - memcpy((void*)&pPipeline->cbStateCI, pTrav, sizeof(VK_PIPELINE_CB_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->cbStateCI, pTrav, sizeof(VkPipelineCbStateCreateInfo)); // Copy embedded ptrs - pCBCI = (VK_PIPELINE_CB_STATE_CREATE_INFO*)pTrav; + pCBCI = (VkPipelineCbStateCreateInfo*)pTrav; pPipeline->attachmentCount = pCBCI->attachmentCount; if (pPipeline->attachmentCount) { - pPipeline->pAttachments = new VK_PIPELINE_CB_ATTACHMENT_STATE[pPipeline->attachmentCount]; - bufferSize = pPipeline->attachmentCount * sizeof(VK_PIPELINE_CB_ATTACHMENT_STATE); - memcpy((void*)pPipeline->pAttachments, ((VK_PIPELINE_CB_STATE_CREATE_INFO*)pTrav)->pAttachments, bufferSize); + pPipeline->pAttachments = new VkPipelineCbAttachmentState[pPipeline->attachmentCount]; + bufferSize = pPipeline->attachmentCount * sizeof(VkPipelineCbAttachmentState); + memcpy((void*)pPipeline->pAttachments, ((VkPipelineCbStateCreateInfo*)pTrav)->pAttachments, bufferSize); } break; case VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO: pPrev->pNext = &pPipeline->dsStateCI; pPrev = (GENERIC_HEADER*)&pPipeline->dsStateCI; - memcpy((void*)&pPipeline->dsStateCI, pTrav, sizeof(VK_PIPELINE_DS_STATE_CREATE_INFO)); + memcpy((void*)&pPipeline->dsStateCI, pTrav, sizeof(VkPipelineDsStateCreateInfo)); break; default: assert(0); @@ -476,7 +476,7 @@ static void initPipeline(PIPELINE_NODE* pPipeline, const VK_GRAPHICS_PIPELINE_CR // Free the Pipeline nodes static void deletePipelines() { - for (unordered_map::iterator ii=pipelineMap.begin(); ii!=pipelineMap.end(); ++ii) { + for (unordered_map::iterator ii=pipelineMap.begin(); ii!=pipelineMap.end(); ++ii) { if ((*ii).second->pVertexBindingDescriptions) { delete[] (*ii).second->pVertexBindingDescriptions; } @@ -490,7 +490,7 @@ static void deletePipelines() } } // For given pipeline, return number of MSAA samples, or one if MSAA disabled -static uint32_t getNumSamples(const VK_PIPELINE pipeline) +static uint32_t getNumSamples(const VkPipeline pipeline) { PIPELINE_NODE* pPipe = pipelineMap[pipeline]; if (VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO == pPipe->msStateCI.sType) { @@ -500,14 +500,14 @@ static uint32_t getNumSamples(const VK_PIPELINE pipeline) return 1; } // Validate state related to the PSO -static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const VK_PIPELINE_BIND_POINT pipelineBindPoint, const VK_PIPELINE pipeline) +static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const VkPipelineBindPoint pipelineBindPoint, const VkPipeline pipeline) { if (VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) { // Verify that any MSAA request in PSO matches sample# in bound FB uint32_t psoNumSamples = getNumSamples(pipeline); if (pCB->activeRenderPass) { - VK_RENDER_PASS_CREATE_INFO* pRPCI = renderPassMap[pCB->activeRenderPass]; - VK_FRAMEBUFFER_CREATE_INFO* pFBCI = frameBufferMap[pCB->framebuffer]; + VkRenderPassCreateInfo* pRPCI = renderPassMap[pCB->activeRenderPass]; + VkFramebufferCreateInfo* pFBCI = frameBufferMap[pCB->framebuffer]; if (psoNumSamples != pFBCI->sampleCount) { char str[1024]; sprintf(str, "Num samples mismatche! Binding PSO (%p) with %u samples while current RenderPass (%p) uses FB (%p) with %u samples!", (void*)pipeline, psoNumSamples, (void*)pCB->activeRenderPass, (void*)pCB->framebuffer, pFBCI->sampleCount); @@ -526,7 +526,7 @@ static void validatePipelineState(const GLOBAL_CB_NODE* pCB, const VK_PIPELINE_B // Block of code at start here specifically for managing/tracking DSs // Return Pool node ptr for specified pool or else NULL -static POOL_NODE* getPoolNode(VK_DESCRIPTOR_POOL pool) +static POOL_NODE* getPoolNode(VkDescriptorPool pool) { loader_platform_thread_lock_mutex(&globalLock); if (poolMap.find(pool) == poolMap.end()) { @@ -537,7 +537,7 @@ static POOL_NODE* getPoolNode(VK_DESCRIPTOR_POOL pool) return poolMap[pool]; } // Return Set node ptr for specified set or else NULL -static SET_NODE* getSetNode(VK_DESCRIPTOR_SET set) +static SET_NODE* getSetNode(VkDescriptorSet set) { loader_platform_thread_lock_mutex(&globalLock); if (setMap.find(set) == setMap.end()) { @@ -549,7 +549,7 @@ static SET_NODE* getSetNode(VK_DESCRIPTOR_SET set) } // Return VK_TRUE if DS Exists and is within an vkBeginDescriptorPoolUpdate() call sequence, otherwise VK_FALSE -static bool32_t dsUpdateActive(VK_DESCRIPTOR_SET ds) +static bool32_t dsUpdateActive(VkDescriptorSet ds) { // Note, both "get" functions use global mutex so this guy does not SET_NODE* pTrav = getSetNode(ds); @@ -562,7 +562,7 @@ static bool32_t dsUpdateActive(VK_DESCRIPTOR_SET ds) return VK_FALSE; } -static LAYOUT_NODE* getLayoutNode(const VK_DESCRIPTOR_SET_LAYOUT layout) { +static LAYOUT_NODE* getLayoutNode(const VkDescriptorSetLayout layout) { loader_platform_thread_lock_mutex(&globalLock); if (layoutMap.find(layout) == layoutMap.end()) { loader_platform_thread_unlock_mutex(&globalLock); @@ -578,15 +578,15 @@ static uint32_t getUpdateBinding(const GENERIC_HEADER* pUpdateStruct) switch (pUpdateStruct->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - return ((VK_UPDATE_SAMPLERS*)pUpdateStruct)->binding; + return ((VkUpdateSamplers*)pUpdateStruct)->binding; case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - return ((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->binding; + return ((VkUpdateSamplerTextures*)pUpdateStruct)->binding; case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - return ((VK_UPDATE_IMAGES*)pUpdateStruct)->binding; + return ((VkUpdateImages*)pUpdateStruct)->binding; case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - return ((VK_UPDATE_BUFFERS*)pUpdateStruct)->binding; + return ((VkUpdateBuffers*)pUpdateStruct)->binding; case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: - return ((VK_UPDATE_AS_COPY*)pUpdateStruct)->binding; + return ((VkUpdateAsCopy*)pUpdateStruct)->binding; default: // TODO : Flag specific error for this case assert(0); @@ -599,16 +599,16 @@ static uint32_t getUpdateArrayIndex(const GENERIC_HEADER* pUpdateStruct) switch (pUpdateStruct->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - return (((VK_UPDATE_SAMPLERS*)pUpdateStruct)->arrayIndex); + return (((VkUpdateSamplers*)pUpdateStruct)->arrayIndex); case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - return (((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->arrayIndex); + return (((VkUpdateSamplerTextures*)pUpdateStruct)->arrayIndex); case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - return (((VK_UPDATE_IMAGES*)pUpdateStruct)->arrayIndex); + return (((VkUpdateImages*)pUpdateStruct)->arrayIndex); case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - return (((VK_UPDATE_BUFFERS*)pUpdateStruct)->arrayIndex); + return (((VkUpdateBuffers*)pUpdateStruct)->arrayIndex); case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: // TODO : Need to understand this case better and make sure code is correct - return (((VK_UPDATE_AS_COPY*)pUpdateStruct)->arrayElement); + return (((VkUpdateAsCopy*)pUpdateStruct)->arrayElement); default: // TODO : Flag specific error for this case assert(0); @@ -621,16 +621,16 @@ static uint32_t getUpdateCount(const GENERIC_HEADER* pUpdateStruct) switch (pUpdateStruct->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - return (((VK_UPDATE_SAMPLERS*)pUpdateStruct)->count); + return (((VkUpdateSamplers*)pUpdateStruct)->count); case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - return (((VK_UPDATE_SAMPLER_TEXTURES*)pUpdateStruct)->count); + return (((VkUpdateSamplerTextures*)pUpdateStruct)->count); case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - return (((VK_UPDATE_IMAGES*)pUpdateStruct)->count); + return (((VkUpdateImages*)pUpdateStruct)->count); case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - return (((VK_UPDATE_BUFFERS*)pUpdateStruct)->count); + return (((VkUpdateBuffers*)pUpdateStruct)->count); case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: // TODO : Need to understand this case better and make sure code is correct - return (((VK_UPDATE_AS_COPY*)pUpdateStruct)->count); + return (((VkUpdateAsCopy*)pUpdateStruct)->count); default: // TODO : Flag specific error for this case assert(0); @@ -669,7 +669,7 @@ static uint32_t getUpdateEndIndex(const LAYOUT_NODE* pLayout, const GENERIC_HEAD static bool32_t validateUpdateType(const LAYOUT_NODE* pLayout, const GENERIC_HEADER* pUpdateStruct) { // First get actual type of update - VK_DESCRIPTOR_TYPE actualType; + VkDescriptorType actualType; uint32_t i = 0; switch (pUpdateStruct->sType) { @@ -680,13 +680,13 @@ static bool32_t validateUpdateType(const LAYOUT_NODE* pLayout, const GENERIC_HEA actualType = VK_DESCRIPTOR_TYPE_SAMPLER_TEXTURE; break; case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - actualType = ((VK_UPDATE_IMAGES*)pUpdateStruct)->descriptorType; + actualType = ((VkUpdateImages*)pUpdateStruct)->descriptorType; break; case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - actualType = ((VK_UPDATE_BUFFERS*)pUpdateStruct)->descriptorType; + actualType = ((VkUpdateBuffers*)pUpdateStruct)->descriptorType; break; case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: - actualType = ((VK_UPDATE_AS_COPY*)pUpdateStruct)->descriptorType; + actualType = ((VkUpdateAsCopy*)pUpdateStruct)->descriptorType; break; default: // TODO : Flag specific error for this case @@ -704,64 +704,64 @@ static bool32_t validateUpdateType(const LAYOUT_NODE* pLayout, const GENERIC_HEA static GENERIC_HEADER* shadowUpdateNode(GENERIC_HEADER* pUpdate) { GENERIC_HEADER* pNewNode = NULL; - VK_UPDATE_SAMPLERS* pUS = NULL; - VK_UPDATE_SAMPLER_TEXTURES* pUST = NULL; - VK_UPDATE_BUFFERS* pUB = NULL; - VK_UPDATE_IMAGES* pUI = NULL; - VK_UPDATE_AS_COPY* pUAC = NULL; + VkUpdateSamplers* pUS = NULL; + VkUpdateSamplerTextures* pUST = NULL; + VkUpdateBuffers* pUB = NULL; + VkUpdateImages* pUI = NULL; + VkUpdateAsCopy* pUAC = NULL; size_t array_size = 0; size_t base_array_size = 0; size_t total_array_size = 0; size_t baseBuffAddr = 0; - VK_IMAGE_VIEW_ATTACH_INFO** ppLocalImageViews = NULL; - VK_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferViews = NULL; + VkImageViewAttachInfo** ppLocalImageViews = NULL; + VkBufferViewAttachInfo** ppLocalBufferViews = NULL; char str[1024]; switch (pUpdate->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - pUS = new VK_UPDATE_SAMPLERS; + pUS = new VkUpdateSamplers; pNewNode = (GENERIC_HEADER*)pUS; - memcpy(pUS, pUpdate, sizeof(VK_UPDATE_SAMPLERS)); - pUS->pSamplers = new VK_SAMPLER[pUS->count]; - array_size = sizeof(VK_SAMPLER) * pUS->count; - memcpy((void*)pUS->pSamplers, ((VK_UPDATE_SAMPLERS*)pUpdate)->pSamplers, array_size); + memcpy(pUS, pUpdate, sizeof(VkUpdateSamplers)); + pUS->pSamplers = new VkSampler[pUS->count]; + array_size = sizeof(VkSampler) * pUS->count; + memcpy((void*)pUS->pSamplers, ((VkUpdateSamplers*)pUpdate)->pSamplers, array_size); break; case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - pUST = new VK_UPDATE_SAMPLER_TEXTURES; + pUST = new VkUpdateSamplerTextures; pNewNode = (GENERIC_HEADER*)pUST; - memcpy(pUST, pUpdate, sizeof(VK_UPDATE_SAMPLER_TEXTURES)); - pUST->pSamplerImageViews = new VK_SAMPLER_IMAGE_VIEW_INFO[pUST->count]; - array_size = sizeof(VK_SAMPLER_IMAGE_VIEW_INFO) * pUST->count; - memcpy((void*)pUST->pSamplerImageViews, ((VK_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews, array_size); + memcpy(pUST, pUpdate, sizeof(VkUpdateSamplerTextures)); + pUST->pSamplerImageViews = new VkSamplerImageViewInfo[pUST->count]; + array_size = sizeof(VkSamplerImageViewInfo) * pUST->count; + memcpy((void*)pUST->pSamplerImageViews, ((VkUpdateSamplerTextures*)pUpdate)->pSamplerImageViews, array_size); for (uint32_t i = 0; i < pUST->count; i++) { - VK_IMAGE_VIEW_ATTACH_INFO** ppIV = (VK_IMAGE_VIEW_ATTACH_INFO**)&pUST->pSamplerImageViews[i].pImageView; - *ppIV = new VK_IMAGE_VIEW_ATTACH_INFO; - memcpy((void*)*ppIV, ((VK_UPDATE_SAMPLER_TEXTURES*)pUpdate)->pSamplerImageViews[i].pImageView, sizeof(VK_IMAGE_VIEW_ATTACH_INFO)); + VkImageViewAttachInfo** ppIV = (VkImageViewAttachInfo**)&pUST->pSamplerImageViews[i].pImageView; + *ppIV = new VkImageViewAttachInfo; + memcpy((void*)*ppIV, ((VkUpdateSamplerTextures*)pUpdate)->pSamplerImageViews[i].pImageView, sizeof(VkImageViewAttachInfo)); } break; case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - pUI = new VK_UPDATE_IMAGES; + pUI = new VkUpdateImages; pNewNode = (GENERIC_HEADER*)pUI; - memcpy(pUI, pUpdate, sizeof(VK_UPDATE_IMAGES)); - pUI->pImageViews = new VK_IMAGE_VIEW_ATTACH_INFO[pUI->count]; - array_size = (sizeof(VK_IMAGE_VIEW_ATTACH_INFO) * pUI->count); - memcpy((void*)pUI->pImageViews, ((VK_UPDATE_IMAGES*)pUpdate)->pImageViews, array_size); + memcpy(pUI, pUpdate, sizeof(VkUpdateImages)); + pUI->pImageViews = new VkImageViewAttachInfo[pUI->count]; + array_size = (sizeof(VkImageViewAttachInfo) * pUI->count); + memcpy((void*)pUI->pImageViews, ((VkUpdateImages*)pUpdate)->pImageViews, array_size); break; case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - pUB = new VK_UPDATE_BUFFERS; + pUB = new VkUpdateBuffers; pNewNode = (GENERIC_HEADER*)pUB; - memcpy(pUB, pUpdate, sizeof(VK_UPDATE_BUFFERS)); - pUB->pBufferViews = new VK_BUFFER_VIEW_ATTACH_INFO[pUB->count]; - array_size = (sizeof(VK_BUFFER_VIEW_ATTACH_INFO) * pUB->count); - memcpy((void*)pUB->pBufferViews, ((VK_UPDATE_BUFFERS*)pUpdate)->pBufferViews, array_size); + memcpy(pUB, pUpdate, sizeof(VkUpdateBuffers)); + pUB->pBufferViews = new VkBufferViewAttachInfo[pUB->count]; + array_size = (sizeof(VkBufferViewAttachInfo) * pUB->count); + memcpy((void*)pUB->pBufferViews, ((VkUpdateBuffers*)pUpdate)->pBufferViews, array_size); break; case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: - pUAC = new VK_UPDATE_AS_COPY; + pUAC = new VkUpdateAsCopy; pUpdate = (GENERIC_HEADER*)pUAC; - memcpy(pUAC, pUpdate, sizeof(VK_UPDATE_AS_COPY)); + memcpy(pUAC, pUpdate, sizeof(VkUpdateAsCopy)); break; default: - sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VK_STRUCTURE_TYPE(pUpdate->sType), pUpdate->sType); + sprintf(str, "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdate->sType), pUpdate->sType); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", str); return NULL; } @@ -770,13 +770,13 @@ static GENERIC_HEADER* shadowUpdateNode(GENERIC_HEADER* pUpdate) return pNewNode; } // For given ds, update its mapping based on ppUpdateArray -static void dsUpdate(VK_DESCRIPTOR_SET ds, uint32_t updateCount, const void** ppUpdateArray) +static void dsUpdate(VkDescriptorSet ds, uint32_t updateCount, const void** ppUpdateArray) { SET_NODE* pSet = getSetNode(ds); loader_platform_thread_lock_mutex(&globalLock); g_lastBoundDescriptorSet = pSet->set; LAYOUT_NODE* pLayout = NULL; - VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pLayoutCI = NULL; + VkDescriptorSetLayoutCreateInfo* pLayoutCI = NULL; // TODO : If pCIList is NULL, flag error // Perform all updates for (uint32_t i = 0; i < updateCount; i++) { @@ -785,7 +785,7 @@ static void dsUpdate(VK_DESCRIPTOR_SET ds, uint32_t updateCount, const void** pp // Make sure that binding is within bounds if (pLayout->createInfo.count < getUpdateBinding(pUpdate)) { char str[1024]; - sprintf(str, "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, getUpdateBinding(pUpdate), string_VK_STRUCTURE_TYPE(pUpdate->sType)); + sprintf(str, "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, getUpdateBinding(pUpdate), string_VkStructureType(pUpdate->sType)); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", str); } else { @@ -793,15 +793,15 @@ static void dsUpdate(VK_DESCRIPTOR_SET ds, uint32_t updateCount, const void** pp if (getBindingEndIndex(pLayout, getUpdateBinding(pUpdate)) < getUpdateEndIndex(pLayout, pUpdate)) { char str[48*1024]; // TODO : Keep count of layout CI structs and size this string dynamically based on that count pLayoutCI = &pLayout->createInfo; - string DSstr = vk_print_vk_descriptor_set_layout_create_info(pLayoutCI, "{DS} "); - sprintf(str, "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VK_STRUCTURE_TYPE(pUpdate->sType), getUpdateBinding(pUpdate), DSstr.c_str()); + string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} "); + sprintf(str, "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VkStructureType(pUpdate->sType), getUpdateBinding(pUpdate), DSstr.c_str()); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", str); } else { // TODO : should we skip update on a type mismatch or force it? // Layout bindings match w/ update ok, now verify that update is of the right type if (!validateUpdateType(pLayout, pUpdate)) { char str[1024]; - sprintf(str, "Descriptor update type of %s does not match overlapping binding type!", string_VK_STRUCTURE_TYPE(pUpdate->sType)); + sprintf(str, "Descriptor update type of %s does not match overlapping binding type!", string_VkStructureType(pUpdate->sType)); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, ds, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", str); } else { @@ -843,20 +843,20 @@ static void freeShadowUpdateTree(SET_NODE* pSet) pFreeUpdate = pShadowUpdate; pShadowUpdate = (GENERIC_HEADER*)pShadowUpdate->pNext; uint32_t index = 0; - VK_UPDATE_SAMPLERS* pUS = NULL; - VK_UPDATE_SAMPLER_TEXTURES* pUST = NULL; - VK_UPDATE_IMAGES* pUI = NULL; - VK_UPDATE_BUFFERS* pUB = NULL; + VkUpdateSamplers* pUS = NULL; + VkUpdateSamplerTextures* pUST = NULL; + VkUpdateImages* pUI = NULL; + VkUpdateBuffers* pUB = NULL; void** ppToFree = NULL; switch (pFreeUpdate->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - pUS = (VK_UPDATE_SAMPLERS*)pFreeUpdate; + pUS = (VkUpdateSamplers*)pFreeUpdate; if (pUS->pSamplers) delete[] pUS->pSamplers; break; case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - pUST = (VK_UPDATE_SAMPLER_TEXTURES*)pFreeUpdate; + pUST = (VkUpdateSamplerTextures*)pFreeUpdate; if (pUST->pSamplerImageViews) { for (index = 0; index < pUST->count; index++) { if (pUST->pSamplerImageViews[index].pImageView) { @@ -867,12 +867,12 @@ static void freeShadowUpdateTree(SET_NODE* pSet) } break; case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - pUI = (VK_UPDATE_IMAGES*)pFreeUpdate; + pUI = (VkUpdateImages*)pFreeUpdate; if (pUI->pImageViews) delete[] pUI->pImageViews; break; case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - pUB = (VK_UPDATE_BUFFERS*)pFreeUpdate; + pUB = (VkUpdateBuffers*)pFreeUpdate; if (pUB->pBufferViews) delete[] pUB->pBufferViews; break; @@ -889,7 +889,7 @@ static void freeShadowUpdateTree(SET_NODE* pSet) // NOTE : Calls to this function should be wrapped in mutex static void deletePools() { - for (unordered_map::iterator ii=poolMap.begin(); ii!=poolMap.end(); ++ii) { + for (unordered_map::iterator ii=poolMap.begin(); ii!=poolMap.end(); ++ii) { SET_NODE* pSet = (*ii).second->pSets; SET_NODE* pFreeSet = pSet; while (pSet) { @@ -913,7 +913,7 @@ static void deletePools() // NOTE : Calls to this function should be wrapped in mutex static void deleteLayouts() { - for (unordered_map::iterator ii=layoutMap.begin(); ii!=layoutMap.end(); ++ii) { + for (unordered_map::iterator ii=layoutMap.begin(); ii!=layoutMap.end(); ++ii) { LAYOUT_NODE* pLayout = (*ii).second; if (pLayout->createInfo.pBinding) { for (uint32_t i=0; icreateInfo.count; i++) { @@ -930,7 +930,7 @@ static void deleteLayouts() } // Currently clearing a set is removing all previous updates to that set // TODO : Validate if this is correct clearing behavior -static void clearDescriptorSet(VK_DESCRIPTOR_SET set) +static void clearDescriptorSet(VkDescriptorSet set) { SET_NODE* pSet = getSetNode(set); if (!pSet) { @@ -943,7 +943,7 @@ static void clearDescriptorSet(VK_DESCRIPTOR_SET set) } } -static void clearDescriptorPool(VK_DESCRIPTOR_POOL pool) +static void clearDescriptorPool(VkDescriptorPool pool) { POOL_NODE* pPool = getPoolNode(pool); if (!pPool) { @@ -961,7 +961,7 @@ static void clearDescriptorPool(VK_DESCRIPTOR_POOL pool) } } // Code here to manage the Cmd buffer LL -static GLOBAL_CB_NODE* getCBNode(VK_CMD_BUFFER cb) +static GLOBAL_CB_NODE* getCBNode(VkCmdBuffer cb) { loader_platform_thread_lock_mutex(&globalLock); if (cmdBufferMap.find(cb) == cmdBufferMap.end()) { @@ -975,7 +975,7 @@ static GLOBAL_CB_NODE* getCBNode(VK_CMD_BUFFER cb) // NOTE : Calls to this function should be wrapped in mutex static void deleteCmdBuffers() { - for (unordered_map::iterator ii=cmdBufferMap.begin(); ii!=cmdBufferMap.end(); ++ii) { + for (unordered_map::iterator ii=cmdBufferMap.begin(); ii!=cmdBufferMap.end(); ++ii) { while (!(*ii).second->pCmds.empty()) { delete (*ii).second->pCmds.back(); (*ii).second->pCmds.pop_back(); @@ -999,7 +999,7 @@ static void addCmd(GLOBAL_CB_NODE* pCB, const CMD_TYPE cmd) layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, pCB->cmdBuffer, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str); } } -static void resetCB(const VK_CMD_BUFFER cb) +static void resetCB(const VkCmdBuffer cb) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB) { @@ -1008,7 +1008,7 @@ static void resetCB(const VK_CMD_BUFFER cb) pCB->pCmds.pop_back(); } // Reset CB state - VK_FLAGS saveFlags = pCB->flags; + VkFlags saveFlags = pCB->flags; uint32_t saveQueueNodeIndex = pCB->queueNodeIndex; memset(pCB, 0, sizeof(GLOBAL_CB_NODE)); pCB->cmdBuffer = cb; @@ -1019,7 +1019,7 @@ static void resetCB(const VK_CMD_BUFFER cb) } // 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 VK_CMD_BUFFER cmdBuffer, const VK_DYNAMIC_STATE_OBJECT state, const VK_STATE_BIND_POINT sType) +static void setLastBoundDynamicState(const VkCmdBuffer cmdBuffer, const VkDynamicStateObject state, const VkStateBindPoint sType) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -1044,7 +1044,7 @@ static void setLastBoundDynamicState(const VK_CMD_BUFFER cmdBuffer, const VK_DYN } } // Print the last bound Gfx Pipeline -static void printPipeline(const VK_CMD_BUFFER cb) +static void printPipeline(const VkCmdBuffer cb) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB) { @@ -1053,13 +1053,13 @@ static void printPipeline(const VK_CMD_BUFFER cb) // nothing to print } else { - string pipeStr = vk_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str(); + string pipeStr = vk_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str(); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", pipeStr.c_str()); } } } // Common Dot dumping code -static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) +static void dsCoreDumpDot(const VkDescriptorSet ds, FILE* pOutFile) { SET_NODE* pSet = getSetNode(ds); if (pSet) { @@ -1067,7 +1067,7 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) char tmp_str[4*1024]; fprintf(pOutFile, "subgraph cluster_DescriptorPool\n{\nlabel=\"Descriptor Pool\"\n"); sprintf(tmp_str, "Pool (%p)", pPool->pool); - char* pGVstr = vk_gv_print_vk_descriptor_pool_create_info(&pPool->createInfo, tmp_str); + char* pGVstr = vk_gv_print_vkdescriptorpoolcreateinfo(&pPool->createInfo, tmp_str); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); fprintf(pOutFile, "subgraph cluster_DescriptorSet\n{\nlabel=\"Descriptor Set (%p)\"\n", pSet->set); @@ -1076,7 +1076,7 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) uint32_t layout_index = 0; ++layout_index; sprintf(tmp_str, "LAYOUT%u", layout_index); - pGVstr = vk_gv_print_vk_descriptor_set_layout_create_info(&pLayout->createInfo, tmp_str); + pGVstr = vk_gv_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, tmp_str); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); if (pSet->pUpdateStructs) { @@ -1089,7 +1089,7 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) uint32_t i = 0; for (i=0; i < pSet->descriptorCount; i++) { if (pSet->ppDescriptors[i]) { - fprintf(pOutFile, "slot%u%s", i, i, string_VK_STRUCTURE_TYPE(pSet->ppDescriptors[i]->sType)); + fprintf(pOutFile, "slot%u%s", i, i, string_VkStructureType(pSet->ppDescriptors[i]->sType)); } } #define NUM_COLORS 7 @@ -1104,13 +1104,13 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) uint32_t colorIdx = 0; fprintf(pOutFile, ">\n];\n"); // Now add the views that are mapped to active descriptors - VK_UPDATE_SAMPLERS* pUS = NULL; - VK_UPDATE_SAMPLER_TEXTURES* pUST = NULL; - VK_UPDATE_IMAGES* pUI = NULL; - VK_UPDATE_BUFFERS* pUB = NULL; - VK_UPDATE_AS_COPY* pUAC = NULL; - VK_SAMPLER_CREATE_INFO* pSCI = NULL; - VK_IMAGE_VIEW_CREATE_INFO* pIVCI = NULL; + VkUpdateSamplers* pUS = NULL; + VkUpdateSamplerTextures* pUST = NULL; + VkUpdateImages* pUI = NULL; + VkUpdateBuffers* pUB = NULL; + VkUpdateAsCopy* pUAC = NULL; + VkSamplerCreateInfo* pSCI = NULL; + VkImageViewCreateInfo* pIVCI = NULL; VkBufferViewCreateInfo* pBVCI = NULL; void** ppNextPtr = NULL; void* pSaveNext = NULL; @@ -1119,40 +1119,40 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) switch (pSet->ppDescriptors[i]->sType) { case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS: - pUS = (VK_UPDATE_SAMPLERS*)pSet->ppDescriptors[i]; + pUS = (VkUpdateSamplers*)pSet->ppDescriptors[i]; pSCI = getSamplerCreateInfo(pUS->pSamplers[i-pUS->arrayIndex]); if (pSCI) { sprintf(tmp_str, "SAMPLER%u", i); - fprintf(pOutFile, "%s", vk_gv_print_vk_sampler_create_info(pSCI, tmp_str)); + fprintf(pOutFile, "%s", vk_gv_print_vksamplercreateinfo(pSCI, tmp_str)); fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str()); } break; case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES: - pUST = (VK_UPDATE_SAMPLER_TEXTURES*)pSet->ppDescriptors[i]; + pUST = (VkUpdateSamplerTextures*)pSet->ppDescriptors[i]; pSCI = getSamplerCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].sampler); if (pSCI) { sprintf(tmp_str, "SAMPLER%u", i); - fprintf(pOutFile, "%s", vk_gv_print_vk_sampler_create_info(pSCI, tmp_str)); + fprintf(pOutFile, "%s", vk_gv_print_vksamplercreateinfo(pSCI, tmp_str)); fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str()); } pIVCI = getImageViewCreateInfo(pUST->pSamplerImageViews[i-pUST->arrayIndex].pImageView->view); if (pIVCI) { sprintf(tmp_str, "IMAGE_VIEW%u", i); - fprintf(pOutFile, "%s", vk_gv_print_vk_image_view_create_info(pIVCI, tmp_str)); + fprintf(pOutFile, "%s", vk_gv_print_vkimageviewcreateinfo(pIVCI, tmp_str)); fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str()); } break; case VK_STRUCTURE_TYPE_UPDATE_IMAGES: - pUI = (VK_UPDATE_IMAGES*)pSet->ppDescriptors[i]; + pUI = (VkUpdateImages*)pSet->ppDescriptors[i]; pIVCI = getImageViewCreateInfo(pUI->pImageViews[i-pUI->arrayIndex].view); if (pIVCI) { sprintf(tmp_str, "IMAGE_VIEW%u", i); - fprintf(pOutFile, "%s", vk_gv_print_vk_image_view_create_info(pIVCI, tmp_str)); + fprintf(pOutFile, "%s", vk_gv_print_vkimageviewcreateinfo(pIVCI, tmp_str)); fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str()); } break; case VK_STRUCTURE_TYPE_UPDATE_BUFFERS: - pUB = (VK_UPDATE_BUFFERS*)pSet->ppDescriptors[i]; + pUB = (VkUpdateBuffers*)pSet->ppDescriptors[i]; pBVCI = getBufferViewCreateInfo(pUB->pBufferViews[i-pUB->arrayIndex].view); if (pBVCI) { sprintf(tmp_str, "BUFFER_VIEW%u", i); @@ -1161,14 +1161,14 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) } break; case VK_STRUCTURE_TYPE_UPDATE_AS_COPY: - pUAC = (VK_UPDATE_AS_COPY*)pSet->ppDescriptors[i]; + pUAC = (VkUpdateAsCopy*)pSet->ppDescriptors[i]; // TODO : Need to validate this code // Save off pNext and set to NULL while printing this struct, then restore it ppNextPtr = (void**)&pUAC->pNext; pSaveNext = *ppNextPtr; *ppNextPtr = NULL; sprintf(tmp_str, "UPDATE_AS_COPY%u", i); - fprintf(pOutFile, "%s", vk_gv_print_vk_update_as_copy(pUAC, tmp_str)); + fprintf(pOutFile, "%s", vk_gv_print_vkupdateascopy(pUAC, tmp_str)); fprintf(pOutFile, "\"DESCRIPTORS\":slot%u -> \"%s\" [color=\"#%s\"];\n", i, tmp_str, edgeColors[colorIdx].c_str()); // Restore next ptr *ppNextPtr = pSaveNext; @@ -1185,7 +1185,7 @@ static void dsCoreDumpDot(const VK_DESCRIPTOR_SET ds, FILE* pOutFile) } } // Dump subgraph w/ DS info -static void dsDumpDot(const VK_CMD_BUFFER cb, FILE* pOutFile) +static void dsDumpDot(const VkCmdBuffer cb, FILE* pOutFile) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB && pCB->lastBoundDescriptorSet) { @@ -1237,14 +1237,14 @@ static void dumpGlobalDotFile(char *outFileName) char* pGVstr = NULL; for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) { if (g_lastBoundDynamicState[i] && g_lastBoundDynamicState[i]->pCreateInfo) { - pGVstr = dynamic_gv_display(g_lastBoundDynamicState[i]->pCreateInfo, string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i)); + pGVstr = dynamic_gv_display(g_lastBoundDynamicState[i]->pCreateInfo, string_VkStateBindPoint((VkStateBindPoint)i)); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); } } fprintf(pOutFile, "}\n"); // close dynamicState subgraph fprintf(pOutFile, "subgraph cluster_PipelineStateObject\n{\nlabel=\"Pipeline State Object\"\n"); - pGVstr = vk_gv_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD"); + pGVstr = vk_gv_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "PSO HEAD"); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); fprintf(pOutFile, "}\n"); @@ -1254,7 +1254,7 @@ static void dumpGlobalDotFile(char *outFileName) } } // Dump a GraphViz dot file showing the pipeline for a given CB -static void dumpDotFile(const VK_CMD_BUFFER cb, string outFileName) +static void dumpDotFile(const VkCmdBuffer cb, string outFileName) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB) { @@ -1267,14 +1267,14 @@ static void dumpDotFile(const VK_CMD_BUFFER cb, string outFileName) char* pGVstr = NULL; for (uint32_t i = 0; i < VK_NUM_STATE_BIND_POINT; i++) { if (pCB->lastBoundDynamicState[i] && pCB->lastBoundDynamicState[i]->pCreateInfo) { - pGVstr = dynamic_gv_display(pCB->lastBoundDynamicState[i]->pCreateInfo, string_VK_STATE_BIND_POINT((VK_STATE_BIND_POINT)i)); + pGVstr = dynamic_gv_display(pCB->lastBoundDynamicState[i]->pCreateInfo, string_VkStateBindPoint((VkStateBindPoint)i)); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); } } fprintf(pOutFile, "}\n"); // close dynamicState subgraph fprintf(pOutFile, "subgraph cluster_PipelineStateObject\n{\nlabel=\"Pipeline State Object\"\n"); - pGVstr = vk_gv_print_vk_graphics_pipeline_create_info(&pPipeTrav->graphicsPipelineCI, "PSO HEAD"); + pGVstr = vk_gv_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "PSO HEAD"); fprintf(pOutFile, "%s", pGVstr); free(pGVstr); fprintf(pOutFile, "}\n"); @@ -1285,7 +1285,7 @@ static void dumpDotFile(const VK_CMD_BUFFER cb, string outFileName) } } // Verify VB Buffer binding -static void validateVBBinding(const VK_CMD_BUFFER cb) +static void validateVBBinding(const VkCmdBuffer cb) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB && pCB->lastBoundPipeline) { @@ -1310,7 +1310,7 @@ static void validateVBBinding(const VK_CMD_BUFFER cb) } } else { - string tmpStr = vk_print_vk_vertex_input_binding_description(&pPipeTrav->pVertexBindingDescriptions[pCB->lastVtxBinding], "{DS}INFO : ").c_str(); + string tmpStr = vk_print_vkvertexinputbindingdescription(&pPipeTrav->pVertexBindingDescriptions[pCB->lastVtxBinding], "{DS}INFO : ").c_str(); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmpStr.c_str()); } } @@ -1318,7 +1318,7 @@ static void validateVBBinding(const VK_CMD_BUFFER cb) } } // Print details of DS config to stdout -static void printDSConfig(const VK_CMD_BUFFER cb) +static void printDSConfig(const VkCmdBuffer cb) { char tmp_str[1024]; char ds_config_str[1024*256] = {0}; // TODO : Currently making this buffer HUGE w/o overrun protection. Need to be smarter, start smaller, and grow as needed. @@ -1329,7 +1329,7 @@ static void printDSConfig(const VK_CMD_BUFFER cb) // Print out pool details sprintf(tmp_str, "Details for pool %p.", (void*)pPool->pool); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str); - string poolStr = vk_print_vk_descriptor_pool_create_info(&pPool->createInfo, " "); + string poolStr = vk_print_vkdescriptorpoolcreateinfo(&pPool->createInfo, " "); sprintf(ds_config_str, "%s", poolStr.c_str()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str); // Print out set details @@ -1342,7 +1342,7 @@ static void printDSConfig(const VK_CMD_BUFFER cb) sprintf(tmp_str, "Layout #%u, (object %p) for DS %p.", index+1, (void*)pLayout->layout, (void*)pSet->set); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", tmp_str); sprintf(prefix, " [L%u] ", index); - string DSLstr = vk_print_vk_descriptor_set_layout_create_info(&pLayout->createInfo, prefix).c_str(); + string DSLstr = vk_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, prefix).c_str(); sprintf(ds_config_str, "%s", DSLstr.c_str()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, DRAWSTATE_NONE, "DS", ds_config_str); index++; @@ -1362,7 +1362,7 @@ static void printDSConfig(const VK_CMD_BUFFER cb) } } -static void printCB(const VK_CMD_BUFFER cb) +static void printCB(const VkCmdBuffer cb) { GLOBAL_CB_NODE* pCB = getCBNode(cb); if (pCB) { @@ -1380,7 +1380,7 @@ static void printCB(const VK_CMD_BUFFER cb) } -static void synchAndPrintDSConfig(const VK_CMD_BUFFER cb) +static void synchAndPrintDSConfig(const VkCmdBuffer cb) { printDSConfig(cb); printPipeline(cb); @@ -1420,13 +1420,13 @@ static void initDrawState(void) } // initialize Layer dispatch table // TODO handle multiple GPUs - vkGetProcAddrType fpNextGPA; + PFN_vkGetProcAddr fpNextGPA; fpNextGPA = pCurObj->pGPA; assert(fpNextGPA); - layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject); + layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalGpu) pCurObj->nextObject); - vkGetProcAddrType fpGetProcAddr = (vkGetProcAddrType)fpNextGPA((VK_PHYSICAL_GPU) pCurObj->nextObject, (char *) "vkGetProcAddr"); + PFN_vkGetProcAddr fpGetProcAddr = (PFN_vkGetProcAddr)fpNextGPA((VkPhysicalGpu) pCurObj->nextObject, (char *) "vkGetProcAddr"); nextTable.GetProcAddr = fpGetProcAddr; if (!globalLockInitialized) @@ -1441,16 +1441,16 @@ static void initDrawState(void) } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&g_initOnce, initDrawState); - VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = nextTable.CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device) { // Free all the memory loader_platform_thread_lock_mutex(&globalLock); @@ -1463,14 +1463,14 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) deletePools(); deleteLayouts(); loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.DestroyDevice(device); + VkResult result = nextTable.DestroyDevice(device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; - VK_RESULT result; + VkResult result; /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */ if (!strcmp(pExtName, "DrawState") || !strcmp(pExtName, "drawStateDumpDotFile") || !strcmp(pExtName, "drawStateDumpCommandBufferDotFile") || !strcmp(pExtName, "drawStateDumpPngFile")) @@ -1478,7 +1478,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const result = VK_SUCCESS; } else if (nextTable.GetExtensionSupport != NULL) { - result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + result = nextTable.GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); } else { result = VK_ERROR_INVALID_EXTENSION; @@ -1486,14 +1486,14 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { if (gpu != NULL) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&g_initOnce, initDrawState); - VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); return result; } else { @@ -1506,25 +1506,25 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) { for (uint32_t i=0; i < cmdBufferCount; i++) { // Validate that cmd buffers have been updated } - VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); + VkResult result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) { // TODO : When wrapped objects (such as dynamic state) are destroyed, need to clean up memory - VK_RESULT result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(object); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) { - VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateBufferView(device, pCreateInfo, pView); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); BUFFER_NODE* pNewNode = new BUFFER_NODE; @@ -1536,9 +1536,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBuf return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) { - VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateImageView(device, pCreateInfo, pView); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); IMAGE_NODE *pNewNode = new IMAGE_NODE; @@ -1550,7 +1550,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMA return result; } -static void track_pipeline(const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +static void track_pipeline(const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { // Create LL HEAD for this Pipeline loader_platform_thread_lock_mutex(&globalLock); @@ -1561,9 +1561,9 @@ static void track_pipeline(const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, loader_platform_thread_unlock_mutex(&globalLock); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { - VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); // Create LL HEAD for this Pipeline char str[1024]; sprintf(str, "Created Gfx Pipeline %p", (void*)*pPipeline); @@ -1574,13 +1574,13 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative( + VkDevice device, + const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipeline basePipeline, + VkPipeline* pPipeline) { - VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); + VkResult result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); // Create LL HEAD for this Pipeline char str[1024]; sprintf(str, "Created Gfx Pipeline %p (derived from pipeline %p)", (void*)*pPipeline, basePipeline); @@ -1591,9 +1591,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( loader_platform_thread_unlock_mutex(&globalLock); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { - VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler); + VkResult result = nextTable.CreateSampler(device, pCreateInfo, pSampler); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); SAMPLER_NODE* pNewNode = new SAMPLER_NODE; @@ -1605,9 +1605,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPL return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) { - VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); + VkResult result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); if (VK_SUCCESS == result) { LAYOUT_NODE* pNewNode = new LAYOUT_NODE; if (NULL == pNewNode) { @@ -1616,20 +1616,20 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, co layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str); } memset(pNewNode, 0, sizeof(LAYOUT_NODE)); - memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)); - pNewNode->createInfo.pBinding = new VK_DESCRIPTOR_SET_LAYOUT_BINDING[pCreateInfo->count]; - memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(VK_DESCRIPTOR_SET_LAYOUT_BINDING)*pCreateInfo->count); + memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(VkDescriptorSetLayoutCreateInfo)); + pNewNode->createInfo.pBinding = new VkDescriptorSetLayoutBinding[pCreateInfo->count]; + memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(VkDescriptorSetLayoutBinding)*pCreateInfo->count); uint32_t totalCount = 0; for (uint32_t i=0; icount; i++) { totalCount += pCreateInfo->pBinding[i].count; if (pCreateInfo->pBinding[i].pImmutableSamplers) { - VK_SAMPLER** ppIS = (VK_SAMPLER**)&pNewNode->createInfo.pBinding[i].pImmutableSamplers; - *ppIS = new VK_SAMPLER[pCreateInfo->pBinding[i].count]; - memcpy(*ppIS, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].count*sizeof(VK_SAMPLER)); + VkSampler** ppIS = (VkSampler**)&pNewNode->createInfo.pBinding[i].pImmutableSamplers; + *ppIS = new VkSampler[pCreateInfo->pBinding[i].count]; + memcpy(*ppIS, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].count*sizeof(VkSampler)); } } if (totalCount > 0) { - pNewNode->pTypes = new VK_DESCRIPTOR_TYPE[totalCount]; + pNewNode->pTypes = new VkDescriptorType[totalCount]; uint32_t offset = 0; uint32_t j = 0; for (uint32_t i=0; icount; i++) { @@ -1651,18 +1651,18 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, co return result; } -VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain) +VkResult VKAPI vkCreateDescriptorSetLayoutChain(VkDevice device, uint32_t setLayoutArrayCount, const VkDescriptorSetLayout* pSetLayoutArray, VkDescriptorSetLayoutChain* pLayoutChain) { - VK_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain); + VkResult result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain); if (VK_SUCCESS == result) { // TODO : Need to capture the layout chains } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode) +VK_LAYER_EXPORT VkResult VKAPI vkBeginDescriptorPoolUpdate(VkDevice device, VkDescriptorUpdateMode updateMode) { - VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); + VkResult result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); POOL_NODE* pPoolNode = poolMap.begin()->second; @@ -1679,9 +1679,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd) +VK_LAYER_EXPORT VkResult VKAPI vkEndDescriptorPoolUpdate(VkDevice device, VkCmdBuffer cmd) { - VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd); + VkResult result = nextTable.EndDescriptorPoolUpdate(device, cmd); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); POOL_NODE* pPoolNode = poolMap.begin()->second; @@ -1706,28 +1706,28 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_C return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) { - VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); + VkResult result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); if (VK_SUCCESS == result) { // Insert this pool into Global Pool LL at head char str[1024]; sprintf(str, "Created Descriptor Pool %p", (void*)*pDescriptorPool); - layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VK_BASE_OBJECT)pDescriptorPool, 0, DRAWSTATE_NONE, "DS", str); + layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (VkBaseObject)pDescriptorPool, 0, DRAWSTATE_NONE, "DS", str); loader_platform_thread_lock_mutex(&globalLock); POOL_NODE* pNewNode = new POOL_NODE; if (NULL == pNewNode) { char str[1024]; sprintf(str, "Out of memory while attempting to allocate POOL_NODE in vkCreateDescriptorPool()"); - layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, (VK_BASE_OBJECT)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str); + layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, (VkBaseObject)*pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", str); } else { memset(pNewNode, 0, sizeof(POOL_NODE)); - VK_DESCRIPTOR_POOL_CREATE_INFO* pCI = (VK_DESCRIPTOR_POOL_CREATE_INFO*)&pNewNode->createInfo; - memcpy((void*)pCI, pCreateInfo, sizeof(VK_DESCRIPTOR_POOL_CREATE_INFO)); + VkDescriptorPoolCreateInfo* pCI = (VkDescriptorPoolCreateInfo*)&pNewNode->createInfo; + memcpy((void*)pCI, pCreateInfo, sizeof(VkDescriptorPoolCreateInfo)); if (pNewNode->createInfo.count) { - size_t typeCountSize = pNewNode->createInfo.count * sizeof(VK_DESCRIPTOR_TYPE_COUNT); - pNewNode->createInfo.pTypeCount = new VK_DESCRIPTOR_TYPE_COUNT[typeCountSize]; + size_t typeCountSize = pNewNode->createInfo.count * sizeof(VkDescriptorTypeCount); + pNewNode->createInfo.pTypeCount = new VkDescriptorTypeCount[typeCountSize]; memcpy((void*)pNewNode->createInfo.pTypeCount, pCreateInfo->pTypeCount, typeCountSize); } pNewNode->poolUsage = poolUsage; @@ -1744,18 +1744,18 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESC return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDescriptorPool descriptorPool) { - VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool); + VkResult result = nextTable.ResetDescriptorPool(descriptorPool); if (VK_SUCCESS == result) { clearDescriptorPool(descriptorPool); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount) +VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { - VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); + VkResult result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); if ((VK_SUCCESS == result) || (*pCount > 0)) { POOL_NODE *pPoolNode = getPoolNode(descriptorPool); if (!pPoolNode) { @@ -1804,7 +1804,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descrip return result; } -VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets) +VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) { for (uint32_t i = 0; i < count; i++) { clearDescriptorSet(pDescriptorSets[i]); @@ -1812,7 +1812,7 @@ VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPo nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets); } -VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray) +VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) { SET_NODE* pSet = getSetNode(descriptorSet); if (!dsUpdateActive(descriptorSet)) { @@ -1828,37 +1828,37 @@ VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_VIEWPORT); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_RASTER); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_COLOR_BLEND); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); insertDynamicState(*pState, (GENERIC_HEADER*)pCreateInfo, VK_STATE_BIND_DEPTH_STENCIL); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) { - VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); GLOBAL_CB_NODE* pCB = new GLOBAL_CB_NODE; @@ -1874,9 +1874,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo) +VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { - VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); + VkResult result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); if (VK_SUCCESS == result) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -1884,7 +1884,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, co resetCB(cmdBuffer); pCB->state = CB_UPDATE_ACTIVE; if (pBeginInfo->pNext) { - VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pCbGfxBI = (VK_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pBeginInfo->pNext; + VkCmdBufferGraphicsBeginInfo* pCbGfxBI = (VkCmdBufferGraphicsBeginInfo*)pBeginInfo->pNext; if (VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO == pCbGfxBI->sType) { pCB->activeRenderPass = pCbGfxBI->renderPassContinue.renderPass; } @@ -1900,9 +1900,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, co return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer) { - VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer); + VkResult result = nextTable.EndCommandBuffer(cmdBuffer); if (VK_SUCCESS == result) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -1920,9 +1920,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer) { - VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer); + VkResult result = nextTable.ResetCommandBuffer(cmdBuffer); if (VK_SUCCESS == result) { resetCB(cmdBuffer); updateCBTracking(cmdBuffer); @@ -1930,7 +1930,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline) +VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -1958,13 +1958,13 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELIN nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state) { setLastBoundDynamicState(cmdBuffer, state, stateBindPoint); nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData) +VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -1985,7 +1985,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_P g_lastBoundDescriptorSet = pDescriptorSets[i]; loader_platform_thread_unlock_mutex(&globalLock); char str[1024]; - sprintf(str, "DS %p bound on pipeline %s", (void*)pDescriptorSets[i], string_VK_PIPELINE_BIND_POINT(pipelineBindPoint)); + sprintf(str, "DS %p bound on pipeline %s", (void*)pDescriptorSets[i], string_VkPipelineBindPoint(pipelineBindPoint)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", str); synchAndPrintDSConfig(cmdBuffer); } @@ -2004,7 +2004,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData); } -VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType) +VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2020,7 +2020,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFF nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); } -VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding) +VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2037,7 +2037,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUF nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding); } -VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2057,7 +2057,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVert nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2077,7 +2077,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t fi nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2097,7 +2097,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2117,7 +2117,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_ nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z) +VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2132,7 +2132,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, ui nextTable.CmdDispatch(cmdBuffer, x, y, z); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset) +VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2147,7 +2147,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUF nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2162,12 +2162,12 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER sr nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, - VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, - VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, const VkImageCopy* pRegions) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2182,10 +2182,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_IMAGE_BLIT* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkImageBlit* pRegions) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2200,10 +2200,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkBufferImageCopy* pRegions) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2218,10 +2218,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_BUFFER destBuffer, - uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkBuffer destBuffer, + uint32_t regionCount, const VkBufferImageCopy* pRegions) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2236,7 +2236,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout) +VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2251,7 +2251,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout); } -VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize dataSize, const uint32_t* pData) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2266,7 +2266,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data) +VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize fillSize, uint32_t data) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2281,10 +2281,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER de nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data); } -VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, - VK_CLEAR_COLOR color, - uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, + VkImage image, VkImageLayout imageLayout, + VkClearColor color, + uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2299,10 +2299,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, +VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer, + VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, - uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) + uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2317,10 +2317,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects) +VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t rectCount, const VkImageResolve* pRects) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2335,7 +2335,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects); } -VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2350,7 +2350,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2365,7 +2365,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT eve nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo) +VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, const VkEventWaitInfo* pWaitInfo) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2380,7 +2380,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVE nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo); } -VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier) +VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, const VkPipelineBarrier* pBarrier) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2395,7 +2395,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier); } -VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags) +VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2410,7 +2410,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POO nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags); } -VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot) +VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2425,7 +2425,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL nextTable.CmdEndQuery(cmdBuffer, queryPool, slot); } -VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount) +VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2440,7 +2440,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); } -VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkGpuSize destOffset) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2455,7 +2455,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMES nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2470,7 +2470,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset) +VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkGpuSize srcOffset) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2485,7 +2485,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkGpuSize destOffset) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2500,49 +2500,49 @@ VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) { - VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); + VkResult result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); if (VK_SUCCESS == result) { // Shadow create info and store in map - VK_FRAMEBUFFER_CREATE_INFO* localFBCI = new VK_FRAMEBUFFER_CREATE_INFO(*pCreateInfo); + VkFramebufferCreateInfo* localFBCI = new VkFramebufferCreateInfo(*pCreateInfo); if (pCreateInfo->pColorAttachments) { - localFBCI->pColorAttachments = new VK_COLOR_ATTACHMENT_BIND_INFO[localFBCI->colorAttachmentCount]; - memcpy((void*)localFBCI->pColorAttachments, pCreateInfo->pColorAttachments, localFBCI->colorAttachmentCount*sizeof(VK_COLOR_ATTACHMENT_BIND_INFO)); + localFBCI->pColorAttachments = new VkColorAttachmentBindInfo[localFBCI->colorAttachmentCount]; + memcpy((void*)localFBCI->pColorAttachments, pCreateInfo->pColorAttachments, localFBCI->colorAttachmentCount*sizeof(VkColorAttachmentBindInfo)); } if (pCreateInfo->pDepthStencilAttachment) { - localFBCI->pDepthStencilAttachment = new VK_DEPTH_STENCIL_BIND_INFO[localFBCI->colorAttachmentCount]; - memcpy((void*)localFBCI->pDepthStencilAttachment, pCreateInfo->pDepthStencilAttachment, localFBCI->colorAttachmentCount*sizeof(VK_DEPTH_STENCIL_BIND_INFO)); + localFBCI->pDepthStencilAttachment = new VkDepthStencilBindInfo[localFBCI->colorAttachmentCount]; + memcpy((void*)localFBCI->pDepthStencilAttachment, pCreateInfo->pDepthStencilAttachment, localFBCI->colorAttachmentCount*sizeof(VkDepthStencilBindInfo)); } frameBufferMap[*pFramebuffer] = localFBCI; } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass) +VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) { - VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); + VkResult result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); if (VK_SUCCESS == result) { // Shadow create info and store in map - VK_RENDER_PASS_CREATE_INFO* localRPCI = new VK_RENDER_PASS_CREATE_INFO(*pCreateInfo); + VkRenderPassCreateInfo* localRPCI = new VkRenderPassCreateInfo(*pCreateInfo); if (pCreateInfo->pColorLoadOps) { - localRPCI->pColorLoadOps = new VK_ATTACHMENT_LOAD_OP[localRPCI->colorAttachmentCount]; - memcpy((void*)localRPCI->pColorLoadOps, pCreateInfo->pColorLoadOps, localRPCI->colorAttachmentCount*sizeof(VK_ATTACHMENT_LOAD_OP)); + localRPCI->pColorLoadOps = new VkAttachmentLoadOp[localRPCI->colorAttachmentCount]; + memcpy((void*)localRPCI->pColorLoadOps, pCreateInfo->pColorLoadOps, localRPCI->colorAttachmentCount*sizeof(VkAttachmentLoadOp)); } if (pCreateInfo->pColorStoreOps) { - localRPCI->pColorStoreOps = new VK_ATTACHMENT_STORE_OP[localRPCI->colorAttachmentCount]; - memcpy((void*)localRPCI->pColorStoreOps, pCreateInfo->pColorStoreOps, localRPCI->colorAttachmentCount*sizeof(VK_ATTACHMENT_STORE_OP)); + localRPCI->pColorStoreOps = new VkAttachmentStoreOp[localRPCI->colorAttachmentCount]; + memcpy((void*)localRPCI->pColorStoreOps, pCreateInfo->pColorStoreOps, localRPCI->colorAttachmentCount*sizeof(VkAttachmentStoreOp)); } if (pCreateInfo->pColorLoadClearValues) { - localRPCI->pColorLoadClearValues = new VK_CLEAR_COLOR[localRPCI->colorAttachmentCount]; - memcpy((void*)localRPCI->pColorLoadClearValues, pCreateInfo->pColorLoadClearValues, localRPCI->colorAttachmentCount*sizeof(VK_CLEAR_COLOR)); + localRPCI->pColorLoadClearValues = new VkClearColor[localRPCI->colorAttachmentCount]; + memcpy((void*)localRPCI->pColorLoadClearValues, pCreateInfo->pColorLoadClearValues, localRPCI->colorAttachmentCount*sizeof(VkClearColor)); } renderPassMap[*pRenderPass] = localRPCI; } return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN *pRenderPassBegin) +VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin *pRenderPassBegin) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2561,7 +2561,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin); } -VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass) +VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer, VkRenderPass renderPass) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2577,7 +2577,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER nextTable.CmdEndRenderPass(cmdBuffer, renderPass); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) { // This layer intercepts callbacks VK_LAYER_DBG_FUNCTION_NODE* pNewDbgFuncNode = new VK_LAYER_DBG_FUNCTION_NODE; @@ -2591,11 +2591,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, V if (g_actionIsDefault) { g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK; } - VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); + VkResult result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) +VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) { VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead; VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav; @@ -2617,11 +2617,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, else g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK)); } - VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); + VkResult result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2636,7 +2636,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const ch nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker); } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer) { GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer); if (pCB) { @@ -2688,7 +2688,7 @@ void drawStateDumpPngFile(char* outFileName) #endif // WIN32 } -VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName) +VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; @@ -2844,6 +2844,6 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcN else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName); + return gpuw->pGPA((VkPhysicalGpu)gpuw->nextObject, funcName); } } diff --git a/layers/draw_state.h b/layers/draw_state.h index 426bf38a..f1404724 100644 --- a/layers/draw_state.h +++ b/layers/draw_state.h @@ -65,84 +65,84 @@ typedef enum _DRAW_TYPE typedef struct _SHADER_DS_MAPPING { uint32_t slotCount; - VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pShaderMappingSlot; + VkDescriptorSetLayoutCreateInfo* pShaderMappingSlot; } SHADER_DS_MAPPING; typedef struct _GENERIC_HEADER { - VK_STRUCTURE_TYPE sType; + VkStructureType sType; const void* pNext; } GENERIC_HEADER; typedef struct _PIPELINE_NODE { - VK_PIPELINE pipeline; - - VK_GRAPHICS_PIPELINE_CREATE_INFO graphicsPipelineCI; - VK_PIPELINE_VERTEX_INPUT_CREATE_INFO vertexInputCI; - VK_PIPELINE_IA_STATE_CREATE_INFO iaStateCI; - VK_PIPELINE_TESS_STATE_CREATE_INFO tessStateCI; - VK_PIPELINE_VP_STATE_CREATE_INFO vpStateCI; - VK_PIPELINE_RS_STATE_CREATE_INFO rsStateCI; - VK_PIPELINE_MS_STATE_CREATE_INFO msStateCI; - VK_PIPELINE_CB_STATE_CREATE_INFO cbStateCI; - VK_PIPELINE_DS_STATE_CREATE_INFO dsStateCI; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO vsCI; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO tcsCI; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO tesCI; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO gsCI; - VK_PIPELINE_SHADER_STAGE_CREATE_INFO fsCI; - // Compute shader is include in VK_COMPUTE_PIPELINE_CREATE_INFO - VK_COMPUTE_PIPELINE_CREATE_INFO computePipelineCI; - - VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateTree; // Ptr to shadow of data in create tree + VkPipeline pipeline; + + VkGraphicsPipelineCreateInfo graphicsPipelineCI; + VkPipelineVertexInputCreateInfo vertexInputCI; + VkPipelineIaStateCreateInfo iaStateCI; + VkPipelineTessStateCreateInfo tessStateCI; + VkPipelineVpStateCreateInfo vpStateCI; + VkPipelineRsStateCreateInfo rsStateCI; + VkPipelineMsStateCreateInfo msStateCI; + VkPipelineCbStateCreateInfo cbStateCI; + VkPipelineDsStateCreateInfo dsStateCI; + VkPipelineShaderStageCreateInfo vsCI; + VkPipelineShaderStageCreateInfo tcsCI; + VkPipelineShaderStageCreateInfo tesCI; + VkPipelineShaderStageCreateInfo gsCI; + VkPipelineShaderStageCreateInfo fsCI; + // Compute shader is include in VkComputePipelineCreateInfo + VkComputePipelineCreateInfo computePipelineCI; + + VkGraphicsPipelineCreateInfo* pCreateTree; // Ptr to shadow of data in create tree // Vtx input info (if any) uint32_t vtxBindingCount; // number of bindings - VK_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions; + VkVertexInputBindingDescription* pVertexBindingDescriptions; uint32_t vtxAttributeCount; // number of attributes - VK_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions; + VkVertexInputAttributeDescription* pVertexAttributeDescriptions; uint32_t attachmentCount; // number of CB attachments - VK_PIPELINE_CB_ATTACHMENT_STATE* pAttachments; + VkPipelineCbAttachmentState* pAttachments; } PIPELINE_NODE; typedef struct _SAMPLER_NODE { - VK_SAMPLER sampler; - VK_SAMPLER_CREATE_INFO createInfo; + VkSampler sampler; + VkSamplerCreateInfo createInfo; } SAMPLER_NODE; typedef struct _IMAGE_NODE { - VK_IMAGE_VIEW image; - VK_IMAGE_VIEW_CREATE_INFO createInfo; - VK_IMAGE_VIEW_ATTACH_INFO attachInfo; + VkImageView image; + VkImageViewCreateInfo createInfo; + VkImageViewAttachInfo attachInfo; } IMAGE_NODE; typedef struct _BUFFER_NODE { - VK_BUFFER_VIEW buffer; + VkBufferView buffer; VkBufferViewCreateInfo createInfo; - VK_BUFFER_VIEW_ATTACH_INFO attachInfo; + VkBufferViewAttachInfo attachInfo; } BUFFER_NODE; typedef struct _DYNAMIC_STATE_NODE { - VK_DYNAMIC_STATE_OBJECT stateObj; + VkDynamicStateObject stateObj; GENERIC_HEADER* pCreateInfo; union { - VK_DYNAMIC_VP_STATE_CREATE_INFO vpci; - VK_DYNAMIC_RS_STATE_CREATE_INFO rsci; - VK_DYNAMIC_CB_STATE_CREATE_INFO cbci; - VK_DYNAMIC_DS_STATE_CREATE_INFO dsci; + VkDynamicVpStateCreateInfo vpci; + VkDynamicRsStateCreateInfo rsci; + VkDynamicCbStateCreateInfo cbci; + VkDynamicDsStateCreateInfo dsci; } create_info; } DYNAMIC_STATE_NODE; // Descriptor Data structures // Layout Node has the core layout data typedef struct _LAYOUT_NODE { - VK_DESCRIPTOR_SET_LAYOUT layout; - VK_DESCRIPTOR_TYPE* pTypes; // Dynamic array that will be created to verify descriptor types - VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO createInfo; + VkDescriptorSetLayout layout; + VkDescriptorType* pTypes; // Dynamic array that will be created to verify descriptor types + VkDescriptorSetLayoutCreateInfo createInfo; uint32_t startIndex; // 1st index of this layout uint32_t endIndex; // last index of this layout } LAYOUT_NODE; typedef struct _SET_NODE { - VK_DESCRIPTOR_SET set; - VK_DESCRIPTOR_POOL pool; - VK_DESCRIPTOR_SET_USAGE setUsage; + VkDescriptorSet set; + VkDescriptorPool pool; + VkDescriptorSetUsage setUsage; // Head of LL of all Update structs for this set GENERIC_HEADER* pUpdateStructs; // Total num of descriptors in this set (count of its layout plus all prior layouts) @@ -153,10 +153,10 @@ typedef struct _SET_NODE { } SET_NODE; typedef struct _POOL_NODE { - VK_DESCRIPTOR_POOL pool; - VK_DESCRIPTOR_POOL_USAGE poolUsage; + VkDescriptorPool pool; + VkDescriptorPoolUsage poolUsage; uint32_t maxSets; - VK_DESCRIPTOR_POOL_CREATE_INFO createInfo; + VkDescriptorPoolCreateInfo createInfo; bool32_t updateActive; // Track if Pool is in an update block SET_NODE* pSets; // Head of LL of sets for this Pool } POOL_NODE; @@ -218,10 +218,10 @@ typedef enum _CB_STATE } CB_STATE; // Cmd Buffer Wrapper Struct typedef struct _GLOBAL_CB_NODE { - VK_CMD_BUFFER cmdBuffer; + VkCmdBuffer cmdBuffer; uint32_t queueNodeIndex; - VK_FLAGS flags; - VK_FENCE fence; // fence tracking this cmd buffer + VkFlags flags; + VkFence fence; // fence tracking this cmd buffer uint64_t numCmds; // number of cmds in this CB uint64_t drawCount[NUM_DRAW_TYPES]; // Count of each type of draw in this CB CB_STATE state; // Track if cmd buffer update status @@ -229,12 +229,12 @@ typedef struct _GLOBAL_CB_NODE { // Currently storing "lastBound" objects on per-CB basis // long-term may want to create caches of "lastBound" states and could have // each individual CMD_NODE referencing its own "lastBound" state - VK_PIPELINE lastBoundPipeline; + VkPipeline lastBoundPipeline; uint32_t lastVtxBinding; DYNAMIC_STATE_NODE* lastBoundDynamicState[VK_NUM_STATE_BIND_POINT]; - VK_DESCRIPTOR_SET lastBoundDescriptorSet; - VK_RENDER_PASS activeRenderPass; - VK_FRAMEBUFFER framebuffer; + VkDescriptorSet lastBoundDescriptorSet; + VkRenderPass activeRenderPass; + VkFramebuffer framebuffer; } GLOBAL_CB_NODE; //prototypes for extension functions diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c index b4a976e8..5180ed70 100644 --- a/layers/glave_snapshot.c +++ b/layers/glave_snapshot.c @@ -139,19 +139,19 @@ void glv_deepfree_VkDeviceCreateInfo(VkDeviceCreateInfo* pCreateInfo) free(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_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { pDest->gpu = gpu; pDest->pCreateInfo = glv_deepcopy_VkDeviceCreateInfo(pCreateInfo); - pDest->pDevice = (VK_DEVICE*)malloc(sizeof(VK_DEVICE)); + pDest->pDevice = (VkDevice*)malloc(sizeof(VkDevice)); *pDest->pDevice = *pDevice; } void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc) { - memset(&pSrc->gpu, 0, sizeof(VK_PHYSICAL_GPU)); + memset(&pSrc->gpu, 0, sizeof(VkPhysicalGpu)); glv_deepfree_VkDeviceCreateInfo(pSrc->pCreateInfo); pSrc->pCreateInfo = NULL; @@ -267,7 +267,7 @@ static void snapshot_insert_deleted_object(GLV_VK_SNAPSHOT* pSnapshot, void* pOb } // Note: the parameters after pSnapshot match the order of vkCreateDevice(..) -static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* 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)); @@ -283,7 +283,7 @@ static void snapshot_insert_device(GLV_VK_SNAPSHOT* pSnapshot, VK_PHYSICAL_GPU g pSnapshot->deviceCount++; } -static void snapshot_remove_device(GLV_VK_SNAPSHOT* pSnapshot, VK_DEVICE device) +static void snapshot_remove_device(GLV_VK_SNAPSHOT* pSnapshot, VkDevice device) { GLV_VK_SNAPSHOT_LL_NODE* pFoundObject = snapshot_remove_object(pSnapshot, device); @@ -331,7 +331,7 @@ static void snapshot_remove_device(GLV_VK_SNAPSHOT* pSnapshot, VK_DEVICE device) } // Traverse global list and return type for given object -static VK_OBJECT_TYPE ll_get_obj_type(VK_OBJECT object) { +static VK_OBJECT_TYPE ll_get_obj_type(VkObject object) { GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pGlobalObjs; while (pTrav) { if (pTrav->obj.pVkObject == object) @@ -386,7 +386,7 @@ static void set_status(void* pObj, VK_OBJECT_TYPE objType, OBJECT_STATUS status_ } // Track selected state for an object node -static void track_object_status(void* pObj, VK_STATE_BIND_POINT stateBindPoint) { +static void track_object_status(void* pObj, VkStateBindPoint stateBindPoint) { GLV_VK_SNAPSHOT_LL_NODE *pTrav = s_delta.pObjectHead[VK_OBJECT_TYPE_CMD_BUFFER]; while (pTrav) { @@ -447,11 +447,11 @@ static void initGlaveSnapshot(void) g_logFile = stdout; } - vkGetProcAddrType fpNextGPA; + PFN_vkGetProcAddr fpNextGPA; fpNextGPA = pCurObj->pGPA; assert(fpNextGPA); - layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject); + layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalGpu) pCurObj->nextObject); if (!objLockInitialized) { // TODO/TBD: Need to delete this mutex sometime. How??? @@ -463,48 +463,48 @@ static void initGlaveSnapshot(void) //============================================================================= // vulkan entrypoints //============================================================================= -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VK_INSTANCE* pInstance) +VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) { - VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance); + VkResult result = nextTable.CreateInstance(pCreateInfo, pInstance); loader_platform_thread_lock_mutex(&objLock); snapshot_insert_object(&s_delta, *pInstance, VK_OBJECT_TYPE_INSTANCE); loader_platform_thread_unlock_mutex(&objLock); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyInstance(VK_INSTANCE instance) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance) { - VK_RESULT result = nextTable.DestroyInstance(instance); + VkResult result = nextTable.DestroyInstance(instance); loader_platform_thread_lock_mutex(&objLock); snapshot_remove_object(&s_delta, (void*)instance); loader_platform_thread_unlock_mutex(&objLock); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateGpus(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateGpus(VkInstance instance, uint32_t maxGpus, uint32_t* pGpuCount, VkPhysicalGpu* pGpus) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)instance, VK_OBJECT_TYPE_INSTANCE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus); + VkResult result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetGpuInfo(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetGpuInfo(VkPhysicalGpu gpu, VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.GetGpuInfo((VK_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData); + VkResult result = nextTable.GetGpuInfo((VkPhysicalGpu)gpuw->nextObject, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = nextTable.CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -514,9 +514,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDevi return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device) { - VK_RESULT result = nextTable.DestroyDevice(device); + VkResult result = nextTable.DestroyDevice(device); loader_platform_thread_lock_mutex(&objLock); snapshot_remove_device(&s_delta, device); loader_platform_thread_unlock_mutex(&objLock); @@ -541,7 +541,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; loader_platform_thread_lock_mutex(&objLock); @@ -549,11 +549,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const loader_platform_thread_unlock_mutex(&objLock); pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + VkResult result = nextTable.GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { if (gpu != NULL) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; @@ -562,7 +562,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma loader_platform_thread_unlock_mutex(&objLock); pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); return result; } else { if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL) @@ -574,43 +574,43 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue) +VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); + VkResult result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) { set_status((void*)fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED); - VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); + VkResult result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue) +VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue) { - VK_RESULT result = nextTable.QueueWaitIdle(queue); + VkResult result = nextTable.QueueWaitIdle(queue); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.DeviceWaitIdle(device); + VkResult result = nextTable.DeviceWaitIdle(device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem); + VkResult result = nextTable.AllocMemory(device, pAllocInfo, pMem); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -621,54 +621,54 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAl return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkGpuMemory mem) { - VK_RESULT result = nextTable.FreeMemory(mem); + VkResult result = nextTable.FreeMemory(mem); loader_platform_thread_lock_mutex(&objLock); snapshot_remove_object(&s_delta, (void*)mem); loader_platform_thread_unlock_mutex(&objLock); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority) +VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkGpuMemory mem, VkMemoryPriority priority) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.SetMemoryPriority(mem, priority); + VkResult result = nextTable.SetMemoryPriority(mem, priority); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData) +VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkGpuMemory mem, VkFlags flags, void** ppData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY); loader_platform_thread_unlock_mutex(&objLock); set_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED); - VK_RESULT result = nextTable.MapMemory(mem, flags, ppData); + VkResult result = nextTable.MapMemory(mem, flags, ppData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkGpuMemory mem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY); loader_platform_thread_unlock_mutex(&objLock); reset_status((void*)mem, VK_OBJECT_TYPE_GPU_MEMORY, OBJSTATUS_GPU_MEM_MAPPED); - VK_RESULT result = nextTable.UnmapMemory(mem); + VkResult result = nextTable.UnmapMemory(mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkPinSystemMemory(VkDevice device, const void* pSysMem, size_t memSize, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); + VkResult result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo) +VK_LAYER_EXPORT VkResult VKAPI vkGetMultiGpuCompatibility(VkPhysicalGpu gpu0, VkPhysicalGpu gpu1, VkGpuCompatibilityInfo* pInfo) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu0; loader_platform_thread_lock_mutex(&objLock); @@ -676,97 +676,97 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility(VK_PHYSICAL_GPU gpu0, loader_platform_thread_unlock_mutex(&objLock); pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.GetMultiGpuCompatibility((VK_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo); + VkResult result = nextTable.GetMultiGpuCompatibility((VkPhysicalGpu)gpuw->nextObject, gpu1, pInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedMemory(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore) +VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedSemaphore(VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore); + VkResult result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerMemory(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); + VkResult result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) { - VK_RESULT result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(object); loader_platform_thread_lock_mutex(&objLock); snapshot_remove_object(&s_delta, (void*)object); loader_platform_thread_unlock_mutex(&objLock); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkBaseObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)object, ll_get_obj_type(object)); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); + VkResult result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkObject object, uint32_t allocationIdx, VkGpuMemory mem, VkGpuSize offset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)object, ll_get_obj_type(object)); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); + VkResult result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemoryRange(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset, VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemoryRange(VkObject object, uint32_t allocationIdx, VkGpuSize rangeOffset, VkGpuSize rangeSize, VkGpuMemory mem, VkGpuSize memOffset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)object, ll_get_obj_type(object)); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); + VkResult result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset) +VK_LAYER_EXPORT VkResult VKAPI vkBindImageMemoryRange(VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* bindInfo, VkGpuMemory mem, VkGpuSize memOffset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)image, VK_OBJECT_TYPE_IMAGE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset); + VkResult result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence); + VkResult result = nextTable.CreateFence(device, pCreateInfo, pFence); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -777,31 +777,31 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_C return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkFence fence) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)fence, VK_OBJECT_TYPE_FENCE); loader_platform_thread_unlock_mutex(&objLock); // Warn if submitted_flag is not set - VK_RESULT result = nextTable.GetFenceStatus(fence); + VkResult result = nextTable.GetFenceStatus(fence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout) +VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); + VkResult result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore); + VkResult result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -812,24 +812,24 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEM return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSignalSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore) +VK_LAYER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) { - VK_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore); + VkResult result = nextTable.QueueSignalSemaphore(queue, semaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore) +VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) { - VK_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore); + VkResult result = nextTable.QueueWaitSemaphore(queue, semaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent) +VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent); + VkResult result = nextTable.CreateEvent(device, pCreateInfo, pEvent); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -840,39 +840,39 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_C return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetEventStatus(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkGetEventStatus(VkEvent event) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.GetEventStatus(event); + VkResult result = nextTable.GetEventStatus(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkSetEvent(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkSetEvent(VkEvent event) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.SetEvent(event); + VkResult result = nextTable.SetEvent(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetEvent(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkResetEvent(VkEvent event) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)event, VK_OBJECT_TYPE_EVENT); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.ResetEvent(event); + VkResult result = nextTable.ResetEvent(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); + VkResult result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -883,30 +883,30 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUE return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetQueryPoolResults(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)queryPool, VK_OBJECT_TYPE_QUERY_POOL); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData); + VkResult result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetFormatInfo(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData); + VkResult result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); + VkResult result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -917,12 +917,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferC return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateBufferView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -933,12 +933,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBuf return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage); + VkResult result = nextTable.CreateImage(device, pCreateInfo, pImage); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -949,21 +949,21 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_C return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceInfo(VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)image, VK_OBJECT_TYPE_IMAGE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData); + VkResult result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateImageView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -974,12 +974,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMA return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -990,12 +990,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, co return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1006,12 +1006,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader) +VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader); + VkResult result = nextTable.CreateShader(device, pCreateInfo, pShader); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1022,12 +1022,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1038,12 +1038,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1054,30 +1054,30 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkStorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkStorePipeline(VkPipeline pipeline, size_t* pDataSize, void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)pipeline, VK_OBJECT_TYPE_PIPELINE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData); + VkResult result = nextTable.StorePipeline(pipeline, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipeline(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkLoadPipeline(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline); + VkResult result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler); + VkResult result = nextTable.CreateSampler(device, pCreateInfo, pSampler); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1088,12 +1088,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPL return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout( VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); + VkResult result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1104,30 +1104,30 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout( VK_DEVICE device, c return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode) +VK_LAYER_EXPORT VkResult VKAPI vkBeginDescriptorPoolUpdate(VkDevice device, VkDescriptorUpdateMode updateMode) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); + VkResult result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd) +VK_LAYER_EXPORT VkResult VKAPI vkEndDescriptorPoolUpdate(VkDevice device, VkCmdBuffer cmd) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd); + VkResult result = nextTable.EndDescriptorPoolUpdate(device, cmd); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); + VkResult result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1138,21 +1138,21 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESC return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDescriptorPool descriptorPool) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool); + VkResult result = nextTable.ResetDescriptorPool(descriptorPool); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount) +VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); + VkResult result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); if (result == VK_SUCCESS) { for (uint32_t i = 0; i < *pCount; i++) { @@ -1165,7 +1165,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descrip return result; } -VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets) +VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)descriptorPool, VK_OBJECT_TYPE_DESCRIPTOR_POOL); @@ -1173,7 +1173,7 @@ VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPo nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets); } -VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray) +VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)descriptorSet, VK_OBJECT_TYPE_DESCRIPTOR_SET); @@ -1181,12 +1181,12 @@ VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpStateObject* pState) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1197,12 +1197,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, c return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsStateObject* pState) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1213,12 +1213,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, con return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbStateObject* pState) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1229,12 +1229,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsStateObject* pState) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1245,12 +1245,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE devic return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1261,16 +1261,16 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo) +VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); + VkResult result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1279,20 +1279,20 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) OBJSTATUS_RASTER_BOUND | OBJSTATUS_COLOR_BLEND_BOUND | OBJSTATUS_DEPTH_STENCIL_BOUND)); - VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer); + VkResult result = nextTable.EndCommandBuffer(cmdBuffer); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer); + VkResult result = nextTable.ResetCommandBuffer(cmdBuffer); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline) +VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1300,7 +1300,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELIN nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1309,7 +1309,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData) +VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1317,7 +1317,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData); } -VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding) +VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1325,7 +1325,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUF nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding); } -VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType) +VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1333,7 +1333,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFF nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); } -VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1341,7 +1341,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVert nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1349,7 +1349,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t fi nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1357,7 +1357,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1365,7 +1365,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_ nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z) +VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1373,7 +1373,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, ui nextTable.CmdDispatch(cmdBuffer, x, y, z); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset) +VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1381,7 +1381,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUF nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1389,7 +1389,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER sr nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1397,7 +1397,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcI nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1405,7 +1405,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BU nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1413,7 +1413,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IM nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout) +VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1421,7 +1421,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout); } -VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize dataSize, const uint32_t* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1429,7 +1429,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data) +VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize fillSize, uint32_t data) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1437,7 +1437,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER de nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data); } -VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1445,7 +1445,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAG nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1453,7 +1453,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IM nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects) +VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t rectCount, const VkImageResolve* pRects) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1461,7 +1461,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE s nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects); } -VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1469,7 +1469,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1477,7 +1477,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT eve nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo) +VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, const VkEventWaitInfo* pWaitInfo) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1485,7 +1485,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVE nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo); } -VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier) +VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, const VkPipelineBarrier* pBarrier) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1493,7 +1493,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier); } -VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags) +VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1501,7 +1501,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POO nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags); } -VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot) +VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1509,7 +1509,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL nextTable.CmdEndQuery(cmdBuffer, queryPool, slot); } -VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount) +VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1517,7 +1517,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); } -VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkGpuSize destOffset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1525,7 +1525,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMES nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1533,7 +1533,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset) +VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkGpuSize srcOffset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1541,7 +1541,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkGpuSize destOffset) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1549,12 +1549,12 @@ VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); + VkResult result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1565,12 +1565,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_F return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass) +VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); + VkResult result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&objLock); @@ -1581,7 +1581,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RE return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN *pRenderPassBegin) +VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin *pRenderPassBegin) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1589,7 +1589,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin); } -VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass) +VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer, VkRenderPass renderPass) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1597,16 +1597,16 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER nextTable.CmdEndRenderPass(cmdBuffer, renderPass); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetValidationLevel(VK_DEVICE device, VK_VALIDATION_LEVEL validationLevel) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetValidationLevel(VkDevice device, VkValidationLevel validationLevel) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel); + VkResult result = nextTable.DbgSetValidationLevel(device, validationLevel); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) { // This layer intercepts callbacks VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE)); @@ -1619,11 +1619,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, V // force callbacks if DebugAction hasn't been set already other than initial value if (g_actionIsDefault) { g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK; - } VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); + } VkResult result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) +VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) { VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead; VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav; @@ -1645,44 +1645,44 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, else g_debugAction &= ~VK_DBG_LAYER_ACTION_CALLBACK; } - VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); + VkResult result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetMessageFilter(VK_DEVICE device, int32_t msgCode, VK_DBG_MSG_FILTER filter) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetMessageFilter(VkDevice device, int32_t msgCode, VK_DBG_MSG_FILTER filter) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter); + VkResult result = nextTable.DbgSetMessageFilter(device, msgCode, filter); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetObjectTag(VK_BASE_OBJECT object, size_t tagSize, const void* pTag) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkBaseObject object, size_t tagSize, const void* pTag) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)object, ll_get_obj_type(object)); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag); + VkResult result = nextTable.DbgSetObjectTag(object, tagSize, pTag); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetGlobalOption(VkInstance instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) { - VK_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData); + VkResult result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetDeviceOption(VK_DEVICE device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetDeviceOption(VkDevice device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData); + VkResult result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1690,7 +1690,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const ch nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker); } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER); @@ -1700,7 +1700,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer) #if defined(__linux__) || defined(XCB_NVIDIA) -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11AssociateConnection(VK_PHYSICAL_GPU gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11AssociateConnection(VkPhysicalGpu gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; loader_platform_thread_lock_mutex(&objLock); @@ -1708,25 +1708,25 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11AssociateConnection(VK_PHYSICAL_GPU gpu, loader_platform_thread_unlock_mutex(&objLock); pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initGlaveSnapshot); - VK_RESULT result = nextTable.WsiX11AssociateConnection((VK_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo); + VkResult result = nextTable.WsiX11AssociateConnection((VkPhysicalGpu)gpuw->nextObject, pConnectionInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11GetMSC(VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11GetMSC(VkDevice device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc); + VkResult result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11CreatePresentableImage(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VkImage* pImage, VkGpuMemory* pMem) { loader_platform_thread_lock_mutex(&objLock); ll_increment_use_count((void*)device, VK_OBJECT_TYPE_DEVICE); loader_platform_thread_unlock_mutex(&objLock); - VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); + VkResult result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); if (result == VK_SUCCESS) { @@ -1743,9 +1743,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11QueuePresent(VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VkFence fence) { - VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); + VkResult result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); return result; } @@ -1858,7 +1858,7 @@ uint64_t glvSnapshotGetObjectCount(VK_OBJECT_TYPE type) return retVal; } -VK_RESULT glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE *pObjNodeArray) +VkResult glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE *pObjNodeArray) { // This bool flags if we're pulling all objs or just a single class of objs bool32_t bAllObjs = (type == VK_OBJECT_TYPE_ANY); @@ -1892,7 +1892,7 @@ void glvSnapshotPrintObjects(void) } #include "vk_generic_intercept_proc_helper.h" -VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName) +VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; void* addr; @@ -1927,7 +1927,7 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcN else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName); + return gpuw->pGPA((VkPhysicalGpu)gpuw->nextObject, funcName); } } diff --git a/layers/glave_snapshot.h b/layers/glave_snapshot.h index f22915cc..f0de0e91 100644 --- a/layers/glave_snapshot.h +++ b/layers/glave_snapshot.h @@ -173,13 +173,13 @@ void glv_vk_malloc_and_copy(void** ppDest, size_t size, const void* pSrc); typedef struct _GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS { - VK_PHYSICAL_GPU gpu; + VkPhysicalGpu gpu; VkDeviceCreateInfo* pCreateInfo; - VK_DEVICE* pDevice; + VkDevice* pDevice; } GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS; 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_copy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pDest, VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); void glv_vk_snapshot_destroy_createdevice_params(GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS* pSrc); //============================================================================= @@ -195,10 +195,10 @@ typedef struct _GLV_VK_SNAPSHOT_OBJECT_NODE { void* pStruct; //< optionally points to a device-specific struct (ie, GLV_VK_SNAPSHOT_DEVICE_NODE) } GLV_VK_SNAPSHOT_OBJECT_NODE; -// Node that stores information about an VK_DEVICE +// Node that stores information about an VkDevice typedef struct _GLV_VK_SNAPSHOT_DEVICE_NODE { // This object - VK_DEVICE device; + VkDevice device; // CreateDevice parameters GLV_VK_SNAPSHOT_CREATEDEVICE_PARAMS params; @@ -291,12 +291,12 @@ void glvSnapshotClear(void); GLV_VK_SNAPSHOT glvSnapshotMerge(const GLV_VK_SNAPSHOT * const pDelta, const GLV_VK_SNAPSHOT * const pSnapshot); uint64_t glvSnapshotGetObjectCount(VK_OBJECT_TYPE type); -VK_RESULT glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE* pObjNodeArray); +VkResult glvSnapshotGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, GLV_VK_SNAPSHOT_OBJECT_NODE* pObjNodeArray); void glvSnapshotPrintObjects(void); // Func ptr typedefs typedef uint64_t (*GLVSNAPSHOT_GET_OBJECT_COUNT)(VK_OBJECT_TYPE); -typedef VK_RESULT (*GLVSNAPSHOT_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, GLV_VK_SNAPSHOT_OBJECT_NODE*); +typedef VkResult (*GLVSNAPSHOT_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, GLV_VK_SNAPSHOT_OBJECT_NODE*); typedef void (*GLVSNAPSHOT_PRINT_OBJECTS)(void); typedef void (*GLVSNAPSHOT_START_TRACKING)(void); typedef GLV_VK_SNAPSHOT (*GLVSNAPSHOT_GET_DELTA)(void); diff --git a/layers/layers_msg.h b/layers/layers_msg.h index b3525967..cda11051 100644 --- a/layers/layers_msg.h +++ b/layers/layers_msg.h @@ -33,8 +33,8 @@ static FILE *g_logFile = NULL; // Utility function to handle reporting // If callbacks are enabled, use them, otherwise use printf static void layerCbMsg(VK_DBG_MSG_TYPE msgType, - VK_VALIDATION_LEVEL validationLevel, - VK_BASE_OBJECT srcObject, + VkValidationLevel validationLevel, + VkBaseObject srcObject, size_t location, int32_t msgCode, const char* pLayerPrefix, diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp index c05e07e2..bde5950a 100644 --- a/layers/mem_tracker.cpp +++ b/layers/mem_tracker.cpp @@ -50,18 +50,18 @@ static loader_platform_thread_mutex globalLock; #define MAX_BINDING 0xFFFFFFFF -map cbMap; -map memObjMap; -map objectMap; +map cbMap; +map memObjMap; +map objectMap; map fenceMap; // Map fenceId to fence info -map queueMap; +map queueMap; // TODO : Add per-device fence completion static uint64_t g_currentFenceId = 1; -static VK_DEVICE globalDevice = NULL; +static VkDevice globalDevice = NULL; // Add new queue for this device to map container -static void addQueueInfo(const VK_QUEUE queue) +static void addQueueInfo(const VkQueue queue) { MT_QUEUE_INFO* pInfo = new MT_QUEUE_INFO; pInfo->lastRetiredId = 0; @@ -72,23 +72,23 @@ static void addQueueInfo(const VK_QUEUE queue) static void deleteQueueInfoList(void) { // Process queue list, cleaning up each entry before deleting - for (map::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) { + for (map::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) { (*ii).second->pQueueCmdBuffers.clear(); } queueMap.clear(); } // Add new CBInfo for this cb to map container -static void addCBInfo(const VK_CMD_BUFFER cb) +static void addCBInfo(const VkCmdBuffer cb) { MT_CB_INFO* pInfo = new MT_CB_INFO; - memset(pInfo, 0, (sizeof(MT_CB_INFO) - sizeof(list))); + memset(pInfo, 0, (sizeof(MT_CB_INFO) - sizeof(list))); pInfo->cmdBuffer = cb; cbMap[cb] = pInfo; } // Return ptr to Info in CB map, or NULL if not found -static MT_CB_INFO* getCBInfo(const VK_CMD_BUFFER cb) +static MT_CB_INFO* getCBInfo(const VkCmdBuffer cb) { MT_CB_INFO* pCBInfo = NULL; if (cbMap.find(cb) != cbMap.end()) { @@ -98,7 +98,7 @@ static MT_CB_INFO* getCBInfo(const VK_CMD_BUFFER cb) } // Return object info for 'object' or return NULL if no info exists -static MT_OBJ_INFO* getObjectInfo(const VK_OBJECT object) +static MT_OBJ_INFO* getObjectInfo(const VkObject object) { MT_OBJ_INFO* pObjInfo = NULL; @@ -108,7 +108,7 @@ static MT_OBJ_INFO* getObjectInfo(const VK_OBJECT object) return pObjInfo; } -static MT_OBJ_INFO* addObjectInfo(VK_OBJECT object, VK_STRUCTURE_TYPE sType, const void *pCreateInfo, const int struct_size, const char *name_prefix) +static MT_OBJ_INFO* addObjectInfo(VkObject object, VkStructureType sType, const void *pCreateInfo, const int struct_size, const char *name_prefix) { MT_OBJ_INFO* pInfo = new MT_OBJ_INFO; memset(pInfo, 0, sizeof(MT_OBJ_INFO)); @@ -124,7 +124,7 @@ static MT_OBJ_INFO* addObjectInfo(VK_OBJECT object, VK_STRUCTURE_TYPE sType, con } // Add a fence, creating one if necessary to our list of fences/fenceIds -static uint64_t addFenceInfo(VK_FENCE fence, VK_QUEUE queue) +static uint64_t addFenceInfo(VkFence fence, VkQueue queue) { // Create fence object MT_FENCE_INFO* pFenceInfo = new MT_FENCE_INFO; @@ -133,12 +133,12 @@ static uint64_t addFenceInfo(VK_FENCE fence, VK_QUEUE queue) memset(pFenceInfo, 0, sizeof(MT_FENCE_INFO)); // If no fence, create an internal fence to track the submissions if (fence == NULL) { - VK_FENCE_CREATE_INFO fci; + VkFenceCreateInfo fci; fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; fci.pNext = NULL; - fci.flags = static_cast(0); + fci.flags = static_cast(0); nextTable.CreateFence(globalDevice, &fci, &pFenceInfo->fence); - addObjectInfo(pFenceInfo->fence, fci.sType, &fci, sizeof(VK_FENCE_CREATE_INFO), "internalFence"); + addObjectInfo(pFenceInfo->fence, fci.sType, &fci, sizeof(VkFenceCreateInfo), "internalFence"); pFenceInfo->localFence = VK_TRUE; } else { pFenceInfo->localFence = VK_FALSE; @@ -171,11 +171,11 @@ static void deleteFenceInfo(uint64_t fenceId) } // Search through list for this fence, deleting all items before it (with lower IDs) and updating lastRetiredId -static void updateFenceTracking(VK_FENCE fence) +static void updateFenceTracking(VkFence fence) { MT_FENCE_INFO *pCurFenceInfo = NULL; uint64_t fenceId = 0; - VK_QUEUE queue = NULL; + VkQueue queue = NULL; for (map::iterator ii=fenceMap.begin(); ii!=fenceMap.end(); ++ii) { if ((*ii).second != NULL) { @@ -214,9 +214,9 @@ static bool32_t fenceRetired(uint64_t fenceId) } // Return the fence associated with a fenceId -static VK_FENCE getFenceFromId(uint64_t fenceId) +static VkFence getFenceFromId(uint64_t fenceId) { - VK_FENCE fence = NULL; + VkFence fence = NULL; if (fenceId != 0) { // Search for an item with this fenceId if (fenceMap.find(fenceId) != fenceMap.end()) { @@ -233,7 +233,7 @@ static VK_FENCE getFenceFromId(uint64_t fenceId) } // Helper routine that updates the fence list for a specific queue to all-retired -static void retireQueueFences(VK_QUEUE queue) +static void retireQueueFences(VkQueue queue) { MT_QUEUE_INFO *pQueueInfo = queueMap[queue]; pQueueInfo->lastRetiredId = pQueueInfo->lastSubmittedId; @@ -253,11 +253,11 @@ static void retireQueueFences(VK_QUEUE queue) } // Helper routine that updates fence list for all queues to all-retired -static void retireDeviceFences(VK_DEVICE device) +static void retireDeviceFences(VkDevice device) { // Process each queue for device // TODO: Add multiple device support - for (map::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) { + for (map::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) { retireQueueFences((*ii).first); } } @@ -265,11 +265,11 @@ static void retireDeviceFences(VK_DEVICE device) // Returns True if a memory reference is present in a Queue's memory reference list // Queue is validated by caller static bool32_t checkMemRef( - VK_QUEUE queue, - VK_GPU_MEMORY mem) + VkQueue queue, + VkGpuMemory mem) { bool32_t result = VK_FALSE; - list::iterator it; + list::iterator it; MT_QUEUE_INFO *pQueueInfo = queueMap[queue]; for (it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) { if ((*it) == mem) { @@ -281,9 +281,9 @@ static bool32_t checkMemRef( } static bool32_t validateQueueMemRefs( - VK_QUEUE queue, + VkQueue queue, uint32_t cmdBufferCount, - const VK_CMD_BUFFER *pCmdBuffers) + const VkCmdBuffer *pCmdBuffers) { bool32_t result = VK_TRUE; @@ -305,7 +305,7 @@ static bool32_t validateQueueMemRefs( result = VK_FALSE; } else { // Validate that all actual references are accounted for in pMemRefs - for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { + for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { // Search for each memref in queues memreflist. if (checkMemRef(queue, *it)) { char str[1024]; @@ -335,7 +335,7 @@ static bool32_t validateQueueMemRefs( // Return ptr to info in map container containing mem, or NULL if not found // Calls to this function should be wrapped in mutex -static MT_MEM_OBJ_INFO* getMemObjInfo(const VK_GPU_MEMORY mem) +static MT_MEM_OBJ_INFO* getMemObjInfo(const VkGpuMemory mem) { MT_MEM_OBJ_INFO* pMemObjInfo = NULL; @@ -345,7 +345,7 @@ static MT_MEM_OBJ_INFO* getMemObjInfo(const VK_GPU_MEMORY mem) return pMemObjInfo; } -static void addMemObjInfo(const VK_GPU_MEMORY mem, const VkMemoryAllocInfo* pAllocInfo) +static void addMemObjInfo(const VkGpuMemory mem, const VkMemoryAllocInfo* pAllocInfo) { MT_MEM_OBJ_INFO* pInfo = new MT_MEM_OBJ_INFO; pInfo->refCount = 0; @@ -362,7 +362,7 @@ static void addMemObjInfo(const VK_GPU_MEMORY mem, const VkMemoryAllocInfo* pAll // Find CB Info and add mem binding to list container // Find Mem Obj Info and add CB binding to list container -static bool32_t updateCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) +static bool32_t updateCBBinding(const VkCmdBuffer cb, const VkGpuMemory mem) { bool32_t result = VK_TRUE; // First update CB binding in MemObj mini CB list @@ -375,7 +375,7 @@ static bool32_t updateCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) } else { // Search for cmd buffer object in memory object's binding list bool32_t found = VK_FALSE; - for (list::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) { + for (list::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) { if ((*it) == cb) { found = VK_TRUE; break; @@ -397,7 +397,7 @@ static bool32_t updateCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) } else { // Search for memory object in cmd buffer's binding list bool32_t found = VK_FALSE; - for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { + for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { if ((*it) == mem) { found = VK_TRUE; break; @@ -414,7 +414,7 @@ static bool32_t updateCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) // Clear the CB Binding for mem // Calls to this function should be wrapped in mutex -static void clearCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) +static void clearCBBinding(const VkCmdBuffer cb, const VkGpuMemory mem) { MT_MEM_OBJ_INFO* pInfo = getMemObjInfo(mem); // TODO : Having this check is not ideal, really if memInfo was deleted, @@ -427,7 +427,7 @@ static void clearCBBinding(const VK_CMD_BUFFER cb, const VK_GPU_MEMORY mem) } // Free bindings related to CB -static bool32_t freeCBBindings(const VK_CMD_BUFFER cb) +static bool32_t freeCBBindings(const VkCmdBuffer cb) { bool32_t result = VK_TRUE; MT_CB_INFO* pCBInfo = getCBInfo(cb); @@ -441,7 +441,7 @@ static bool32_t freeCBBindings(const VK_CMD_BUFFER cb) deleteFenceInfo(pCBInfo->fenceId); } - for (list::iterator it=pCBInfo->pMemObjList.begin(); it!=pCBInfo->pMemObjList.end(); ++it) { + for (list::iterator it=pCBInfo->pMemObjList.begin(); it!=pCBInfo->pMemObjList.end(); ++it) { clearCBBinding(cb, (*it)); } pCBInfo->pMemObjList.clear(); @@ -452,7 +452,7 @@ static bool32_t freeCBBindings(const VK_CMD_BUFFER cb) // Delete CBInfo from list along with all of it's mini MemObjInfo // and also clear mem references to CB // TODO : When should this be called? There's no Destroy of CBs that I see -static bool32_t deleteCBInfo(const VK_CMD_BUFFER cb) +static bool32_t deleteCBInfo(const VkCmdBuffer cb) { bool32_t result = VK_TRUE; result = freeCBBindings(cb); @@ -471,7 +471,7 @@ static bool32_t deleteCBInfo(const VK_CMD_BUFFER cb) static bool32_t deleteCBInfoList() { bool32_t result = VK_TRUE; - for (map::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) { + for (map::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) { freeCBBindings((*ii).first); delete (*ii).second; } @@ -483,13 +483,13 @@ static void reportMemReferences(const MT_MEM_OBJ_INFO* pMemObjInfo) { uint32_t refCount = 0; // Count found references - for (list::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) { + for (list::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) { refCount++; char str[1024]; sprintf(str, "Command Buffer %p has reference to mem obj %p", (*it), pMemObjInfo->mem); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str); } - for (list::const_iterator it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) { + for (list::const_iterator it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) { char str[1024]; sprintf(str, "VK Object %p has reference to mem obj %p", (*it), pMemObjInfo->mem); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, (*it), 0, MEMTRACK_NONE, "MEM", str); @@ -501,7 +501,7 @@ static void reportMemReferences(const MT_MEM_OBJ_INFO* pMemObjInfo) } } -static void deleteMemObjInfo(VK_GPU_MEMORY mem) +static void deleteMemObjInfo(VkGpuMemory mem) { MT_MEM_OBJ_INFO* pDelInfo = memObjMap[mem]; if (memObjMap.find(mem) != memObjMap.end()) { @@ -512,7 +512,7 @@ static void deleteMemObjInfo(VK_GPU_MEMORY mem) } // Check if fence for given CB is completed -static bool32_t checkCBCompleted(const VK_CMD_BUFFER cb) +static bool32_t checkCBCompleted(const VkCmdBuffer cb) { bool32_t result = VK_TRUE; MT_CB_INFO* pCBInfo = getCBInfo(cb); @@ -532,7 +532,7 @@ static bool32_t checkCBCompleted(const VK_CMD_BUFFER cb) return result; } -static bool32_t freeMemObjInfo(VK_GPU_MEMORY mem, bool internal) +static bool32_t freeMemObjInfo(VkGpuMemory mem, bool internal) { bool32_t result = VK_TRUE; // Parse global list to find info w/ mem @@ -552,8 +552,8 @@ static bool32_t freeMemObjInfo(VK_GPU_MEMORY mem, bool internal) // Clear any CB bindings for completed CBs // TODO : Is there a better place to do this? - list::iterator it = pInfo->pCmdBufferBindings.begin(); - list::iterator temp; + list::iterator it = pInfo->pCmdBufferBindings.begin(); + list::iterator temp; while (it != pInfo->pCmdBufferBindings.end()) { if (VK_TRUE == checkCBCompleted(*it)) { temp = it; @@ -585,7 +585,7 @@ static bool32_t freeMemObjInfo(VK_GPU_MEMORY mem, bool internal) // 1. Remove ObjectInfo from MemObjInfo list container of obj bindings & free it // 2. Decrement refCount for MemObjInfo // 3. Clear MemObjInfo ptr from ObjectInfo -static bool32_t clearObjectBinding(VK_OBJECT object) +static bool32_t clearObjectBinding(VkObject object) { bool32_t result = VK_FALSE; MT_OBJ_INFO* pObjInfo = getObjectInfo(object); @@ -599,7 +599,7 @@ static bool32_t clearObjectBinding(VK_OBJECT object) sprintf(str, "Attempting to clear mem binding on obj %p but it has no binding.", (void*)object); layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM", str); } else { - for (list::iterator it = pObjInfo->pMemObjInfo->pObjBindings.begin(); it != pObjInfo->pMemObjInfo->pObjBindings.end(); ++it) { + for (list::iterator it = pObjInfo->pMemObjInfo->pObjBindings.begin(); it != pObjInfo->pMemObjInfo->pObjBindings.end(); ++it) { pObjInfo->pMemObjInfo->refCount--; pObjInfo->pMemObjInfo = NULL; it = pObjInfo->pMemObjInfo->pObjBindings.erase(it); @@ -623,7 +623,7 @@ static bool32_t clearObjectBinding(VK_OBJECT object) // Add reference from objectInfo to memoryInfo // Add reference off of objInfo // Return VK_TRUE if addition is successful, VK_FALSE otherwise -static bool32_t updateObjectBinding(VK_OBJECT object, VK_GPU_MEMORY mem) +static bool32_t updateObjectBinding(VkObject object, VkGpuMemory mem) { bool32_t result = VK_FALSE; // Handle NULL case separately, just clear previous binding & decrement reference @@ -646,7 +646,7 @@ static bool32_t updateObjectBinding(VK_OBJECT object, VK_GPU_MEMORY mem) } else { // Search for object in memory object's binding list bool32_t found = VK_FALSE; - for (list::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) { + for (list::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) { if ((*it) == object) { found = VK_TRUE; break; @@ -683,7 +683,7 @@ static void printObjList() char str[1024]; sprintf(str, "Details of Object list of size %lu elements", objectMap.size()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (map::iterator ii=objectMap.begin(); ii!=objectMap.end(); ++ii) { + for (map::iterator ii=objectMap.begin(); ii!=objectMap.end(); ++ii) { pInfo = (*ii).second; sprintf(str, " ObjInfo %p has object %p, pMemObjInfo %p", pInfo, pInfo->object, pInfo->pMemObjInfo); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, pInfo->object, 0, MEMTRACK_NONE, "MEM", str); @@ -691,9 +691,9 @@ static void printObjList() } // For given Object, get 'mem' obj that it's bound to or NULL if no binding -static VK_GPU_MEMORY getMemBindingFromObject(const VK_OBJECT object) +static VkGpuMemory getMemBindingFromObject(const VkObject object) { - VK_GPU_MEMORY mem = NULL; + VkGpuMemory mem = NULL; MT_OBJ_INFO* pObjInfo = getObjectInfo(object); if (pObjInfo) { if (pObjInfo->pMemObjInfo) { @@ -724,7 +724,7 @@ static void printMemList() sprintf(str, "MEM INFO : Details of Memory Object list of size %lu elements", memObjMap.size()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (map::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) { + for (map::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) { pInfo = (*ii).second; sprintf(str, " ===MemObjInfo at %p===", (void*)pInfo); @@ -744,14 +744,14 @@ static void printMemList() sprintf(str, " VK OBJECT Binding list of size %lu elements:", pInfo->pObjBindings.size()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (list::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) { + for (list::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) { sprintf(str, " VK OBJECT %p", (*it)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); } sprintf(str, " VK Command Buffer (CB) binding list of size %lu elements", pInfo->pCmdBufferBindings.size()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (list::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) { + for (list::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) { sprintf(str, " VK CB %p", (*it)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); } @@ -765,7 +765,7 @@ static void printCBList() sprintf(str, "Details of CB list of size %lu elements", cbMap.size()); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (map::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) { + for (map::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) { pCBInfo = (*ii).second; sprintf(str, " CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %p", @@ -773,7 +773,7 @@ static void printCBList() (void*)getFenceFromId(pCBInfo->fenceId)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); - for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { + for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { sprintf(str, " Mem obj %p", (*it)); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, MEMTRACK_NONE, "MEM", str); } @@ -800,13 +800,13 @@ static void initMemTracker(void) // initialize Layer dispatch table // TODO handle multiple GPUs - vkGetProcAddrType fpNextGPA; + PFN_vkGetProcAddr fpNextGPA; fpNextGPA = pCurObj->pGPA; assert(fpNextGPA); - layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject); + layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalGpu) pCurObj->nextObject); - vkGetProcAddrType fpGetProcAddr = (vkGetProcAddrType)fpNextGPA((VK_PHYSICAL_GPU) pCurObj->nextObject, (char *) "vkGetProcAddr"); + PFN_vkGetProcAddr fpGetProcAddr = (PFN_vkGetProcAddr)fpNextGPA((VkPhysicalGpu) pCurObj->nextObject, (char *) "vkGetProcAddr"); nextTable.GetProcAddr = fpGetProcAddr; if (!globalLockInitialized) @@ -821,18 +821,18 @@ static void initMemTracker(void) } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&g_initOnce, initMemTracker); - VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = nextTable.CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); // Save off device in case we need it to create Fences globalDevice = *pDevice; return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device) { char str[1024]; sprintf(str, "Printing List details prior to vkDestroyDevice()"); @@ -847,7 +847,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) } // Report any memory leaks MT_MEM_OBJ_INFO* pInfo = NULL; - for (map::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) { + for (map::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) { pInfo = (*ii).second; if (pInfo->allocInfo.allocationSize != 0) { @@ -861,21 +861,21 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) deleteQueueInfoList(); loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.DestroyDevice(device); + VkResult result = nextTable.DestroyDevice(device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; - VK_RESULT result; + VkResult result; /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */ if (!strcmp(pExtName, "MemTracker")) { result = VK_SUCCESS; } else if (nextTable.GetExtensionSupport != NULL) { - result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + result = nextTable.GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); } else { result = VK_ERROR_INVALID_EXTENSION; @@ -883,7 +883,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { if (gpu != NULL) @@ -891,7 +891,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&g_initOnce, initMemTracker); - VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, + VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); return result; } else @@ -905,9 +905,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue) +VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue) { - VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); + VkResult result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); addQueueInfo(*pQueue); @@ -916,9 +916,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queu return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueAddMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReference(VkQueue queue, VkGpuMemory mem) { - VK_RESULT result = nextTable.QueueAddMemReference(queue, mem); + VkResult result = nextTable.QueueAddMemReference(queue, mem); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); @@ -945,10 +945,10 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueAddMemReference(VK_QUEUE queue, VK_GPU_ME return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkQueueRemoveMemReference(VkQueue queue, VkGpuMemory mem) { // TODO : Decrement ref count for this memory reference on this queue. Remove if ref count is zero. - VK_RESULT result = nextTable.QueueRemoveMemReference(queue, mem); + VkResult result = nextTable.QueueRemoveMemReference(queue, mem); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); @@ -959,7 +959,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str); } else { - for (list::iterator it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) { + for (list::iterator it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) { if ((*it) == mem) { it = pQueueInfo->pMemRefList.erase(it); } @@ -970,11 +970,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit( - VK_QUEUE queue, +VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit( + VkQueue queue, uint32_t cmdBufferCount, - const VK_CMD_BUFFER *pCmdBuffers, - VK_FENCE fence) + const VkCmdBuffer *pCmdBuffers, + VkFence fence) { loader_platform_thread_lock_mutex(&globalLock); // TODO : Need to track fence and clear mem references when fence clears @@ -995,13 +995,13 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit( } loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, getFenceFromId(fenceId)); + VkResult result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, getFenceFromId(fenceId)); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkGpuMemory* pMem) { - VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem); + VkResult result = nextTable.AllocMemory(device, pAllocInfo, pMem); // TODO : Track allocations and overall size here loader_platform_thread_lock_mutex(&globalLock); addMemObjInfo(*pMem, pAllocInfo); @@ -1010,7 +1010,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAl return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkGpuMemory mem) { /* From spec : A memory object is freed by calling vkFreeMemory() when it is no longer needed. Before * freeing a memory object, an application must ensure the memory object is unbound from @@ -1026,19 +1026,19 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem) printObjList(); printCBList(); loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.FreeMemory(mem); + VkResult result = nextTable.FreeMemory(mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority) +VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkGpuMemory mem, VkMemoryPriority priority) { // TODO : Update tracking for this alloc // Make sure memory is not pinned, which can't have priority set - VK_RESULT result = nextTable.SetMemoryPriority(mem, priority); + VkResult result = nextTable.SetMemoryPriority(mem, priority); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData) +VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkGpuMemory mem, VkFlags flags, void** ppData) { // TODO : Track when memory is mapped loader_platform_thread_lock_mutex(&globalLock); @@ -1049,54 +1049,54 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, v layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str); } loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.MapMemory(mem, flags, ppData); + VkResult result = nextTable.MapMemory(mem, flags, ppData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkGpuMemory mem) { // TODO : Track as memory gets unmapped, do we want to check what changed following map? // Make sure that memory was ever mapped to begin with - VK_RESULT result = nextTable.UnmapMemory(mem); + VkResult result = nextTable.UnmapMemory(mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkPinSystemMemory(VkDevice device, const void* pSysMem, size_t memSize, VkGpuMemory* pMem) { // TODO : Track this // Verify that memory is actually pinnable - VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); + VkResult result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedMemory(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { // TODO : Track this - VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerMemory(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { // TODO : Track this - VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkGpuMemory* pMem) { // TODO : Track this - VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); + VkResult result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) { loader_platform_thread_lock_mutex(&globalLock); // First check if this is a CmdBuffer - if (NULL != getCBInfo((VK_CMD_BUFFER)object)) { - deleteCBInfo((VK_CMD_BUFFER)object); + if (NULL != getCBInfo((VkCmdBuffer)object)) { + deleteCBInfo((VkCmdBuffer)object); } if (objectMap.find(object) != objectMap.end()) { @@ -1104,7 +1104,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) if (pDelInfo->pMemObjInfo) { // Wsi allocated Memory is tied to image object so clear the binding and free that memory automatically if (0 == pDelInfo->pMemObjInfo->allocInfo.allocationSize) { // Wsi allocated memory has NULL allocInfo w/ 0 size - VK_GPU_MEMORY memToFree = pDelInfo->pMemObjInfo->mem; + VkGpuMemory memToFree = pDelInfo->pMemObjInfo->mem; clearObjectBinding(object); freeMemObjInfo(memToFree, true); } @@ -1121,22 +1121,22 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) } loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(object); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkBaseObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) { // TODO : What to track here? // Could potentially save returned mem requirements and validate values passed into BindObjectMemory for this object // From spec : The only objects that are guaranteed to have no external memory requirements are devices, queues, command buffers, shaders and memory objects. - VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); + VkResult result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkObject object, uint32_t allocationIdx, VkGpuMemory mem, VkGpuSize offset) { - VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); + VkResult result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); loader_platform_thread_lock_mutex(&globalLock); // Track objects tied to memory if (VK_FALSE == updateObjectBinding(object, mem)) { @@ -1150,20 +1150,20 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t al return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) { - VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence); + VkResult result = nextTable.CreateFence(device, pCreateInfo, pFence); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pFence, pCreateInfo->sType, pCreateInfo, sizeof(VK_FENCE_CREATE_INFO), "fence"); + addObjectInfo(*pFence, pCreateInfo->sType, pCreateInfo, sizeof(VkFenceCreateInfo), "fence"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences) +VK_LAYER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, VkFence* pFences) { - VK_RESULT result = nextTable.ResetFences(device, fenceCount, pFences); + VkResult result = nextTable.ResetFences(device, fenceCount, pFences); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); // Reset fence state in fenceCreateInfo structure @@ -1171,7 +1171,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCo MT_OBJ_INFO* pObjectInfo = getObjectInfo(pFences[i]); if (pObjectInfo != NULL) { pObjectInfo->create_info.fence_create_info.flags = - static_cast(pObjectInfo->create_info.fence_create_info.flags & ~VK_FENCE_CREATE_SIGNALED_BIT); + static_cast(pObjectInfo->create_info.fence_create_info.flags & ~VK_FENCE_CREATE_SIGNALED_BIT); } } loader_platform_thread_unlock_mutex(&globalLock); @@ -1179,9 +1179,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCo return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkFence fence) { - VK_RESULT result = nextTable.GetFenceStatus(fence); + VkResult result = nextTable.GetFenceStatus(fence); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); updateFenceTracking(fence); @@ -1190,7 +1190,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence) return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout) +VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout) { // Verify fence status of submitted fences for(uint32_t i = 0; i < fenceCount; i++) { @@ -1204,7 +1204,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fence } } - VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); + VkResult result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); loader_platform_thread_lock_mutex(&globalLock); if (VK_SUCCESS == result) { @@ -1218,9 +1218,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fence return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue) +VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue) { - VK_RESULT result = nextTable.QueueWaitIdle(queue); + VkResult result = nextTable.QueueWaitIdle(queue); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); retireQueueFences(queue); @@ -1229,9 +1229,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue) return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device) { - VK_RESULT result = nextTable.DeviceWaitIdle(device); + VkResult result = nextTable.DeviceWaitIdle(device); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); retireDeviceFences(device); @@ -1240,31 +1240,31 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device) return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent) +VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) { - VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent); + VkResult result = nextTable.CreateEvent(device, pCreateInfo, pEvent); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pEvent, pCreateInfo->sType, pCreateInfo, sizeof(VK_EVENT_CREATE_INFO), "event"); + addObjectInfo(*pEvent, pCreateInfo->sType, pCreateInfo, sizeof(VkEventCreateInfo), "event"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) { - VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); + VkResult result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pQueryPool, pCreateInfo->sType, pCreateInfo, sizeof(VK_QUERY_POOL_CREATE_INFO), "query_pool"); + addObjectInfo(*pQueryPool, pCreateInfo->sType, pCreateInfo, sizeof(VkQueryPoolCreateInfo), "query_pool"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) { - VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); + VkResult result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); addObjectInfo(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferCreateInfo), "buffer"); @@ -1273,9 +1273,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferC return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) { - VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateBufferView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferViewCreateInfo), "buffer_view"); @@ -1284,156 +1284,156 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBuf return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) { - VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage); + VkResult result = nextTable.CreateImage(device, pCreateInfo, pImage); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(VK_IMAGE_CREATE_INFO), "image"); + addObjectInfo(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(VkImageCreateInfo), "image"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) { - VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateImageView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_IMAGE_VIEW_CREATE_INFO), "image_view"); + addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkImageViewCreateInfo), "image_view"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, - VK_COLOR_ATTACHMENT_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, + VkColorAttachmentView* pView) { - VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO), "color_attachment_view"); + addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkColorAttachmentViewCreateInfo), "color_attachment_view"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) { - VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VK_DEPTH_STENCIL_VIEW_CREATE_INFO), "ds_view"); + addObjectInfo(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkDepthStencilViewCreateInfo), "ds_view"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader) +VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) { - VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader); + VkResult result = nextTable.CreateShader(device, pCreateInfo, pShader); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { - VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline"); + addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative( - VK_DEVICE device, - const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE basePipeline, - VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative( + VkDevice device, + const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipeline basePipeline, + VkPipeline* pPipeline) { - VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); + VkResult result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline"); + addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { - VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VK_COMPUTE_PIPELINE_CREATE_INFO), "compute_pipeline"); + addObjectInfo(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkComputePipelineCreateInfo), "compute_pipeline"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { - VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler); + VkResult result = nextTable.CreateSampler(device, pCreateInfo, pSampler); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(VK_SAMPLER_CREATE_INFO), "sampler"); + addObjectInfo(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(VkSamplerCreateInfo), "sampler"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_VP_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, + VkDynamicVpStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_VP_STATE_CREATE_INFO), "viewport_state"); + addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicVpStateCreateInfo), "viewport_state"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_RS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, + VkDynamicRsStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_RS_STATE_CREATE_INFO), "raster_state"); + addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicRsStateCreateInfo), "raster_state"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_CB_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, + VkDynamicCbStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_CB_STATE_CREATE_INFO), "cb_state"); + addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicCbStateCreateInfo), "cb_state"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, - VK_DYNAMIC_DS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, + VkDynamicDsStateObject* pState) { - VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); - addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VK_DYNAMIC_DS_STATE_CREATE_INFO), "ds_state"); + addObjectInfo(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicDsStateCreateInfo), "ds_state"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) { - VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); // At time of cmd buffer creation, create global cmd buffer info for the returned cmd buffer loader_platform_thread_lock_mutex(&globalLock); if (*pCmdBuffer) @@ -1443,7 +1443,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, const VK return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo) +VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { // This implicitly resets the Cmd Buffer so make sure any fence is done and then clear memory references MT_CB_INFO* pCBInfo = getCBInfo(cmdBuffer); @@ -1455,21 +1455,21 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, co layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str); } } - VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); + VkResult result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); loader_platform_thread_lock_mutex(&globalLock); freeCBBindings(cmdBuffer); loader_platform_thread_unlock_mutex(&globalLock); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer) { // TODO : Anything to do here? - VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer); + VkResult result = nextTable.EndCommandBuffer(cmdBuffer); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer) { // Verify that CB is complete (not in-flight) MT_CB_INFO* pCBInfo = getCBInfo(cmdBuffer); @@ -1485,12 +1485,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) loader_platform_thread_lock_mutex(&globalLock); freeCBBindings(cmdBuffer); loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer); + VkResult result = nextTable.ResetCommandBuffer(cmdBuffer); return result; } // TODO : For any vkCmdBind* calls that include an object which has mem bound to it, // need to account for that mem now having binding to given cmdBuffer -VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline) +VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { #if 0 // TODO : If memory bound to pipeline, then need to tie that mem to cmdBuffer @@ -1513,7 +1513,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELIN nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state) { MT_OBJ_INFO *pObjInfo; loader_platform_thread_lock_mutex(&globalLock); @@ -1535,32 +1535,32 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, } VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets( - VK_CMD_BUFFER cmdBuffer, - VK_PIPELINE_BIND_POINT pipelineBindPoint, - VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, - const VK_DESCRIPTOR_SET* pDescriptorSets, + const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData) { // TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData); } -VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding) +VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding) { nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding); } -VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType) +VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType) { nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(buffer); + VkGpuMemory mem = getMemBindingFromObject(buffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdDrawIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer); @@ -1570,10 +1570,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(buffer); + VkGpuMemory mem = getMemBindingFromObject(buffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdDrawIndexedIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer); @@ -1583,10 +1583,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_ nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset) +VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(buffer); + VkGpuMemory mem = getMemBindingFromObject(buffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdDispatchIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer); @@ -1596,11 +1596,11 @@ VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUF nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, - uint32_t regionCount, const VK_BUFFER_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, + uint32_t regionCount, const VkBufferCopy* pRegions) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(srcBuffer); + VkGpuMemory mem = getMemBindingFromObject(srcBuffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdCopyBuffer() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer); @@ -1616,32 +1616,32 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER sr nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkImageCopy* pRegions) { // TODO : Each image will have mem mapping so track them nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_IMAGE_BLIT* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkImageBlit* pRegions) { // TODO : Each image will have mem mapping so track them nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, - VK_BUFFER srcBuffer, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t regionCount, const VkBufferImageCopy* pRegions) { // TODO : Track this loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(destImage); + VkGpuMemory mem = getMemBindingFromObject(destImage); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdCopyMemoryToImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer); @@ -1658,14 +1658,14 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_BUFFER destBuffer, - uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkBuffer destBuffer, + uint32_t regionCount, const VkBufferImageCopy* pRegions) { // TODO : Track this loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage); + VkGpuMemory mem = getMemBindingFromObject(srcImage); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdCopyImageToMemory() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer); @@ -1681,12 +1681,12 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout) +VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout) { // TODO : Each image will have mem mapping so track them loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage); + VkGpuMemory mem = getMemBindingFromObject(srcImage); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdCloneImageData() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer); @@ -1702,10 +1702,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout); } -VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize dataSize, const uint32_t* pData) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(destBuffer); + VkGpuMemory mem = getMemBindingFromObject(destBuffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdUpdateMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer); @@ -1715,10 +1715,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data) +VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize fillSize, uint32_t data) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(destBuffer); + VkGpuMemory mem = getMemBindingFromObject(destBuffer); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdFillMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer); @@ -1728,14 +1728,14 @@ VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER de nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data); } -VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, - VK_CLEAR_COLOR color, - uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, + VkImage image, VkImageLayout imageLayout, + VkClearColor color, + uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(image); + VkGpuMemory mem = getMemBindingFromObject(image); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdClearColorImage() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer); @@ -1745,14 +1745,14 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, +VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer, + VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, - uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) + uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(image); + VkGpuMemory mem = getMemBindingFromObject(image); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdClearDepthStencil() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer); @@ -1762,13 +1762,13 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, - VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, - VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, - uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects) +VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, + VkImage srcImage, VkImageLayout srcImageLayout, + VkImage destImage, VkImageLayout destImageLayout, + uint32_t rectCount, const VkImageResolve* pRects) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(srcImage); + VkGpuMemory mem = getMemBindingFromObject(srcImage); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdResolveImage() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer); @@ -1784,10 +1784,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects); } -VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags) +VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool); + VkGpuMemory mem = getMemBindingFromObject(queryPool); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdBeginQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer); @@ -1797,10 +1797,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POO nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags); } -VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot) +VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool); + VkGpuMemory mem = getMemBindingFromObject(queryPool); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdEndQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer); @@ -1810,10 +1810,10 @@ VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL nextTable.CmdEndQuery(cmdBuffer, queryPool, slot); } -VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount) +VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) { loader_platform_thread_lock_mutex(&globalLock); - VK_GPU_MEMORY mem = getMemBindingFromObject(queryPool); + VkGpuMemory mem = getMemBindingFromObject(queryPool); if (VK_FALSE == updateCBBinding(cmdBuffer, mem)) { char str[1024]; sprintf(str, "In vkCmdResetQueryPool() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer); @@ -1823,7 +1823,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) { // This layer intercepts callbacks VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE)); @@ -1837,11 +1837,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, V if (g_actionIsDefault) { g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK; } - VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); + VkResult result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) +VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) { VK_LAYER_DBG_FUNCTION_NODE *pInfo = g_pDbgFunctionHead; VK_LAYER_DBG_FUNCTION_NODE *pPrev = pInfo; @@ -1864,19 +1864,19 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK)); } } - VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); + VkResult result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); return result; } #if !defined(WIN32) -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, - VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11CreatePresentableImage(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, + VkImage* pImage, VkGpuMemory* pMem) { - VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); + VkResult result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); loader_platform_thread_lock_mutex(&globalLock); if (VK_SUCCESS == result) { // Add image object, then insert the new Mem Object and then bind it to created image - addObjectInfo(*pImage, _VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, sizeof(VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), "wsi_x11_image"); + addObjectInfo(*pImage, VkStructureType__MAX_ENUM, pCreateInfo, sizeof(VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), "wsi_x11_image"); addMemObjInfo(*pMem, NULL); if (VK_FALSE == updateObjectBinding(*pImage, *pMem)) { char str[1024]; @@ -1890,7 +1890,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11QueuePresent(VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VkFence fence) { loader_platform_thread_lock_mutex(&globalLock); addFenceInfo(fence, queue); @@ -1898,12 +1898,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WS sprintf(str, "In vkWsiX11QueuePresent(), checking queue %p for fence %p", queue, fence); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_NONE, "MEM", str); loader_platform_thread_unlock_mutex(&globalLock); - VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); + VkResult result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); return result; } #endif // WIN32 -VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName) +VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; @@ -2063,6 +2063,6 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcN else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName); + return gpuw->pGPA((VkPhysicalGpu)gpuw->nextObject, funcName); } } diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h index d3a8608f..b0b9d6b8 100644 --- a/layers/mem_tracker.h +++ b/layers/mem_tracker.h @@ -85,29 +85,29 @@ typedef enum _MEM_TRACK_ERROR // Data struct for tracking memory object struct MT_MEM_OBJ_INFO { uint32_t refCount; // Count of references (obj bindings or CB use) - VK_GPU_MEMORY mem; + VkGpuMemory mem; VkMemoryAllocInfo allocInfo; - list pObjBindings; // list container of objects bound to this memory - list pCmdBufferBindings; // list container of cmd buffers that reference this mem object + list pObjBindings; // list container of objects bound to this memory + list pCmdBufferBindings; // list container of cmd buffers that reference this mem object }; struct MT_OBJ_INFO { MT_MEM_OBJ_INFO* pMemObjInfo; - VK_OBJECT object; - VK_STRUCTURE_TYPE sType; + VkObject object; + VkStructureType sType; uint32_t ref_count; // Capture all object types that may have memory bound. From prog guide: // The only objects that are guaranteed to have no external memory // requirements are devices, queues, command buffers, shaders and memory objects. union { - VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO color_attachment_view_create_info; - VK_DEPTH_STENCIL_VIEW_CREATE_INFO ds_view_create_info; - VK_IMAGE_VIEW_CREATE_INFO image_view_create_info; - VK_IMAGE_CREATE_INFO image_create_info; - VK_GRAPHICS_PIPELINE_CREATE_INFO graphics_pipeline_create_info; - VK_COMPUTE_PIPELINE_CREATE_INFO compute_pipeline_create_info; - VK_SAMPLER_CREATE_INFO sampler_create_info; - VK_FENCE_CREATE_INFO fence_create_info; + VkColorAttachmentViewCreateInfo color_attachment_view_create_info; + VkDepthStencilViewCreateInfo ds_view_create_info; + VkImageViewCreateInfo image_view_create_info; + VkImageCreateInfo image_create_info; + VkGraphicsPipelineCreateInfo graphics_pipeline_create_info; + VkComputePipelineCreateInfo compute_pipeline_create_info; + VkSamplerCreateInfo sampler_create_info; + VkFenceCreateInfo fence_create_info; #ifndef _WIN32 VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO wsi_x11_presentable_image_create_info; #endif // _WIN32 @@ -117,21 +117,21 @@ struct MT_OBJ_INFO { // Track all command buffers struct MT_CB_INFO { - VK_CMD_BUFFER_CREATE_INFO createInfo; + VkCmdBufferCreateInfo createInfo; MT_OBJ_INFO* pDynamicState[VK_NUM_STATE_BIND_POINT]; - VK_PIPELINE pipelines[VK_NUM_PIPELINE_BIND_POINT]; + VkPipeline pipelines[VK_NUM_PIPELINE_BIND_POINT]; uint32_t colorAttachmentCount; - VK_DEPTH_STENCIL_BIND_INFO dsBindInfo; - VK_CMD_BUFFER cmdBuffer; + VkDepthStencilBindInfo dsBindInfo; + VkCmdBuffer cmdBuffer; uint64_t fenceId; // Order dependent, stl containers must be at end of struct - list pMemObjList; // List container of Mem objs referenced by this CB + list pMemObjList; // List container of Mem objs referenced by this CB }; // Associate fenceId with a fence object struct MT_FENCE_INFO { - VK_FENCE fence; // Handle to fence object - VK_QUEUE queue; // Queue that this fence is submitted against + VkFence fence; // Handle to fence object + VkQueue queue; // Queue that this fence is submitted against bool32_t localFence; // Is fence created by layer? }; @@ -139,8 +139,8 @@ struct MT_FENCE_INFO { struct MT_QUEUE_INFO { uint64_t lastRetiredId; uint64_t lastSubmittedId; - list pQueueCmdBuffers; - list pMemRefList; + list pQueueCmdBuffers; + list pMemRefList; }; #ifdef __cplusplus diff --git a/layers/multi.cpp b/layers/multi.cpp index 3f967d6a..1c9dc178 100644 --- a/layers/multi.cpp +++ b/layers/multi.cpp @@ -62,44 +62,44 @@ extern "C" { #endif -VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, - VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI multi1CreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, + VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; VK_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw); printf("At start of multi1 layer vkCreateDevice()\n"); - VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = pTable->CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); // create a mapping for the device object into the dispatch table tableMap1.emplace(*pDevice, pTable); printf("Completed multi1 layer vkCreateDevice()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi1CreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, - VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI multi1CreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, + VkPipeline* pPipeline) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[device]; printf("At start of multi1 layer vkCreateGraphicsPipeline()\n"); - VK_RESULT result = pTable->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = pTable->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); // create a mapping for the pipeline object into the dispatch table tableMap1.emplace(*pPipeline, pTable); printf("Completed multi1 layer vkCreateGraphicsPipeline()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi1StorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI multi1StorePipeline(VkPipeline pipeline, size_t* pDataSize, void* pData) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[pipeline]; printf("At start of multi1 layer vkStorePipeline()\n"); - VK_RESULT result = pTable->StorePipeline(pipeline, pDataSize, pData); + VkResult result = pTable->StorePipeline(pipeline, pDataSize, pData); printf("Completed multi1 layer vkStorePipeline()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi1EnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, +VK_LAYER_EXPORT VkResult VKAPI multi1EnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { @@ -110,12 +110,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI multi1EnumerateLayers(VK_PHYSICAL_GPU gpu, size_ VK_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw); printf("At start of multi1 layer vkEnumerateLayers()\n"); - VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = pTable->EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); printf("Completed multi1 layer vkEnumerateLayers()\n"); return result; } -VK_LAYER_EXPORT void * VKAPI multi1GetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName) +VK_LAYER_EXPORT void * VKAPI multi1GetProcAddr(VkPhysicalGpu gpu, const char* pName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; @@ -137,7 +137,7 @@ VK_LAYER_EXPORT void * VKAPI multi1GetProcAddr(VK_PHYSICAL_GPU gpu, const char* else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName); + return gpuw->pGPA((VkPhysicalGpu) gpuw->nextObject, pName); } } @@ -163,45 +163,45 @@ static VK_LAYER_DISPATCH_TABLE * getLayer2Table(const VK_BASE_LAYER_OBJECT *gpuw } } -VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, - VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI multi2CreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, + VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; VK_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw); printf("At start of multi2 vkCreateDevice()\n"); - VK_RESULT result = pTable->CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = pTable->CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); // create a mapping for the device object into the dispatch table for layer2 tableMap2.emplace(*pDevice, pTable); printf("Completed multi2 layer vkCreateDevice()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi2CreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, - VK_CMD_BUFFER* pCmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI multi2CreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, + VkCmdBuffer* pCmdBuffer) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[device]; printf("At start of multi2 layer vkCreateCommandBuffer()\n"); - VK_RESULT result = pTable->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult result = pTable->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); // create a mapping for CmdBuffer object into the dispatch table for layer 2 tableMap2.emplace(*pCmdBuffer, pTable); printf("Completed multi2 layer vkCreateCommandBuffer()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi2BeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo) +VK_LAYER_EXPORT VkResult VKAPI multi2BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[cmdBuffer]; printf("At start of multi2 layer vkBeginCommandBuffer()\n"); - VK_RESULT result = pTable->BeginCommandBuffer(cmdBuffer, pBeginInfo); + VkResult result = pTable->BeginCommandBuffer(cmdBuffer, pBeginInfo); printf("Completed multi2 layer vkBeginCommandBuffer()\n"); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI multi2EnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, +VK_LAYER_EXPORT VkResult VKAPI multi2EnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { @@ -212,12 +212,12 @@ VK_LAYER_EXPORT VK_RESULT VKAPI multi2EnumerateLayers(VK_PHYSICAL_GPU gpu, size_ VK_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw); printf("At start of multi2 layer vkEnumerateLayers()\n"); - VK_RESULT result = pTable->EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = pTable->EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); printf("Completed multi2 layer vkEnumerateLayers()\n"); return result; } -VK_LAYER_EXPORT void * VKAPI multi2GetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName) +VK_LAYER_EXPORT void * VKAPI multi2GetProcAddr(VkPhysicalGpu gpu, const char* pName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; @@ -239,12 +239,12 @@ VK_LAYER_EXPORT void * VKAPI multi2GetProcAddr(VK_PHYSICAL_GPU gpu, const char* else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU) gpuw->nextObject, pName); + return gpuw->pGPA((VkPhysicalGpu) gpuw->nextObject, pName); } } /********************************* Common functions ********************************/ -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { @@ -259,9 +259,9 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma return VK_SUCCESS; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { - VK_RESULT result; + VkResult result; VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */ @@ -274,11 +274,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const } else if (!tableMap1.empty() && (tableMap1.find(gpuw) != tableMap1.end())) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[gpuw]; - result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + result = pTable->GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); } else if (!tableMap2.empty() && (tableMap2.find(gpuw) != tableMap2.end())) { VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[gpuw]; - result = pTable->GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + result = pTable->GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); } else { result = VK_ERROR_INVALID_EXTENSION; @@ -286,7 +286,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const return result; } -VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* pName) +VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* pName) { // to find each layers GPA routine Loader will search via "GetProcAddr" if (!strncmp("multi1GetProcAddr", pName, sizeof("multi1GetProcAddr"))) @@ -317,5 +317,5 @@ static void initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw, VK_LAYER_DISPATCH_T if (layerNum == 1 && layer2_first_activated == false) layer1_first_activated = true; - layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VK_PHYSICAL_GPU) gpuw->nextObject); + layer_initialize_dispatch_table(pTable, gpuw->pGPA, (VkPhysicalGpu) gpuw->nextObject); } diff --git a/layers/object_track.h b/layers/object_track.h index a0050c86..cc45d7e3 100644 --- a/layers/object_track.h +++ b/layers/object_track.h @@ -174,8 +174,8 @@ typedef struct _OBJTRACK_NODE { // prototype for extension functions uint64_t objTrackGetObjectCount(VK_OBJECT_TYPE type); -VK_RESULT objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray); +VkResult objTrackGetObjects(VK_OBJECT_TYPE type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray); // Func ptr typedefs typedef uint64_t (*OBJ_TRACK_GET_OBJECT_COUNT)(VK_OBJECT_TYPE); -typedef VK_RESULT (*OBJ_TRACK_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, OBJTRACK_NODE*); +typedef VkResult (*OBJ_TRACK_GET_OBJECTS)(VK_OBJECT_TYPE, uint64_t, OBJTRACK_NODE*); diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp index 9be48ade..bd9646e1 100644 --- a/layers/param_checker.cpp +++ b/layers/param_checker.cpp @@ -64,18 +64,18 @@ static void initParamChecker(void) g_logFile = stdout; } - vkGetProcAddrType fpNextGPA; + PFN_vkGetProcAddr fpNextGPA; fpNextGPA = pCurObj->pGPA; assert(fpNextGPA); - layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VK_PHYSICAL_GPU) pCurObj->nextObject); + layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalGpu) pCurObj->nextObject); } -void PreCreateInstance(const VK_APPLICATION_INFO* pAppInfo, const VK_ALLOC_CALLBACKS* pAllocCb) +void PreCreateInstance(const VkApplicationInfo* pAppInfo, const VkAllocCallbacks* pAllocCb) { if(pAppInfo == nullptr) { - char const str[] = "vkCreateInstance parameter, VK_APPLICATION_INFO* pAppInfo, is "\ + char const str[] = "vkCreateInstance parameter, VkApplicationInfo* pAppInfo, is "\ "nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -97,7 +97,7 @@ void PreCreateInstance(const VK_APPLICATION_INFO* pAppInfo, const VK_ALLOC_CALLB { if(!vk_validate_vk_alloc_callbacks(pAllocCb)) { - char const str[] = "vkCreateInstance parameter, VK_ALLOC_CALLBACKS* pAllocCb, "\ + char const str[] = "vkCreateInstance parameter, VkAllocCallbacks* pAllocCb, "\ "contains an invalid value (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -105,11 +105,11 @@ void PreCreateInstance(const VK_APPLICATION_INFO* pAppInfo, const VK_ALLOC_CALLB } } -void PostCreateInstance(VK_RESULT result, VK_INSTANCE* pInstance) +void PostCreateInstance(VkResult result, VkInstance* pInstance) { if(result != VK_SUCCESS) { - // TODO: Spit out VK_RESULT value. + // TODO: Spit out VkResult value. char const str[] = "vkCreateInstance failed (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -117,36 +117,36 @@ void PostCreateInstance(VK_RESULT result, VK_INSTANCE* pInstance) if(pInstance == nullptr) { - char const str[] = "vkCreateInstance parameter, VK_INSTANCE* pInstance, is nullptr "\ + char const str[] = "vkCreateInstance parameter, VkInstance* pInstance, is nullptr "\ "(postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VK_INSTANCE* pInstance) +VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) { PreCreateInstance(pCreateInfo->pAppInfo, pCreateInfo->pAllocCb); - VK_RESULT result = nextTable.CreateInstance(pCreateInfo, pInstance); + VkResult result = nextTable.CreateInstance(pCreateInfo, pInstance); PostCreateInstance(result, pInstance); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyInstance(VK_INSTANCE instance) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance) { - VK_RESULT result = nextTable.DestroyInstance(instance); + VkResult result = nextTable.DestroyInstance(instance); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateGpus(VK_INSTANCE instance, uint32_t maxGpus, uint32_t* pGpuCount, VK_PHYSICAL_GPU* pGpus) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateGpus(VkInstance instance, uint32_t maxGpus, uint32_t* pGpuCount, VkPhysicalGpu* pGpus) { - VK_RESULT result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus); + VkResult result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetGpuInfo(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GPU_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetGpuInfo(VkPhysicalGpu gpu, VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; @@ -156,15 +156,15 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetGpuInfo(VK_PHYSICAL_GPU gpu, VK_PHYSICAL_GP sprintf(str, "Parameter infoType to function GetGpuInfo has invalid value of %i.", (int)infoType); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.GetGpuInfo((VK_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData); + VkResult result = nextTable.GetGpuInfo((VkPhysicalGpu)gpuw->nextObject, infoType, pDataSize, pData); return result; } -void PreCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo) +void PreCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo) { if(gpu == nullptr) { - char const str[] = "vkCreateDevice parameter, VK_PHYSICAL_GPU gpu, is nullptr "\ + char const str[] = "vkCreateDevice parameter, VkPhysicalGpu gpu, is nullptr "\ "(precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -216,18 +216,18 @@ void PreCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo) if(!validate_VK_VALIDATION_LEVEL(pCreateInfo->maxValidationLevel)) { - char const str[] = "vkCreateDevice parameter, VK_VALIDATION_LEVEL pCreateInfo->maxValidationLevel, is "\ + char const str[] = "vkCreateDevice parameter, VkValidationLevel pCreateInfo->maxValidationLevel, is "\ "unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -void PostCreateDevice(VK_RESULT result, VK_DEVICE* pDevice) +void PostCreateDevice(VkResult result, VkDevice* pDevice) { if(result != VK_SUCCESS) { - // TODO: Spit out VK_RESULT value. + // TODO: Spit out VkResult value. char const str[] = "vkCreateDevice failed (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -235,41 +235,41 @@ void PostCreateDevice(VK_RESULT result, VK_DEVICE* pDevice) if(pDevice == nullptr) { - char const str[] = "vkCreateDevice parameter, VK_DEVICE* pDevice, is nullptr (postcondition)."; + char const str[] = "vkCreateDevice parameter, VkDevice* pDevice, is nullptr (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDevice(VK_PHYSICAL_GPU gpu, const VkDeviceCreateInfo* pCreateInfo, VK_DEVICE* pDevice) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initParamChecker); PreCreateDevice(gpu, pCreateInfo); - VK_RESULT result = nextTable.CreateDevice((VK_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice); + VkResult result = nextTable.CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice); PostCreateDevice(result, pDevice); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyDevice(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device) { - VK_RESULT result = nextTable.DestroyDevice(device); + VkResult result = nextTable.DestroyDevice(device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetExtensionSupport(VK_PHYSICAL_GPU gpu, const char* pExtName) +VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initParamChecker); - VK_RESULT result = nextTable.GetExtensionSupport((VK_PHYSICAL_GPU)gpuw->nextObject, pExtName); + VkResult result = nextTable.GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) +VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved) { char str[1024]; if (gpu != NULL) { @@ -278,7 +278,7 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str); pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initParamChecker); - VK_RESULT result = nextTable.EnumerateLayers((VK_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); + VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved); sprintf(str, "Completed layered EnumerateLayers\n"); layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str); fflush(stdout); @@ -293,45 +293,45 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkEnumerateLayers(VK_PHYSICAL_GPU gpu, size_t ma } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetDeviceQueue(VK_DEVICE device, uint32_t queueNodeIndex, uint32_t queueIndex, VK_QUEUE* pQueue) +VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue) { - VK_RESULT result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); + VkResult result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSubmit(VK_QUEUE queue, uint32_t cmdBufferCount, const VK_CMD_BUFFER* pCmdBuffers, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) { - VK_RESULT result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); + VkResult result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueAddMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReference(VkQueue queue, VkGpuMemory mem) { - VK_RESULT result = nextTable.QueueAddMemReference(queue, mem); + VkResult result = nextTable.QueueAddMemReference(queue, mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueRemoveMemReference(VK_QUEUE queue, VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkQueueRemoveMemReference(VkQueue queue, VkGpuMemory mem) { - VK_RESULT result = nextTable.QueueRemoveMemReference(queue, mem); + VkResult result = nextTable.QueueRemoveMemReference(queue, mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitIdle(VK_QUEUE queue) +VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue) { - VK_RESULT result = nextTable.QueueWaitIdle(queue); + VkResult result = nextTable.QueueWaitIdle(queue); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDeviceWaitIdle(VK_DEVICE device) +VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device) { - VK_RESULT result = nextTable.DeviceWaitIdle(device); + VkResult result = nextTable.DeviceWaitIdle(device); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAllocInfo* pAllocInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkGpuMemory* pMem) { char str[1024]; if (!pAllocInfo) { @@ -341,60 +341,60 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocMemory(VK_DEVICE device, const VkMemoryAl 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); } - VK_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem); + VkResult result = nextTable.AllocMemory(device, pAllocInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkFreeMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(VkGpuMemory mem) { - VK_RESULT result = nextTable.FreeMemory(mem); + VkResult result = nextTable.FreeMemory(mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkSetMemoryPriority(VK_GPU_MEMORY mem, VK_MEMORY_PRIORITY priority) +VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkGpuMemory mem, VkMemoryPriority priority) { char str[1024]; if (!validate_VK_MEMORY_PRIORITY(priority)) { sprintf(str, "Parameter priority to function SetMemoryPriority has invalid value of %i.", (int)priority); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.SetMemoryPriority(mem, priority); + VkResult result = nextTable.SetMemoryPriority(mem, priority); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkMapMemory(VK_GPU_MEMORY mem, VK_FLAGS flags, void** ppData) +VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(VkGpuMemory mem, VkFlags flags, void** ppData) { - VK_RESULT result = nextTable.MapMemory(mem, flags, ppData); + VkResult result = nextTable.MapMemory(mem, flags, ppData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkUnmapMemory(VK_GPU_MEMORY mem) +VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(VkGpuMemory mem) { - VK_RESULT result = nextTable.UnmapMemory(mem); + VkResult result = nextTable.UnmapMemory(mem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkPinSystemMemory(VK_DEVICE device, const void* pSysMem, size_t memSize, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkPinSystemMemory(VkDevice device, const void* pSysMem, size_t memSize, VkGpuMemory* pMem) { - VK_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); + VkResult result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetMultiGpuCompatibility(VK_PHYSICAL_GPU gpu0, VK_PHYSICAL_GPU gpu1, VK_GPU_COMPATIBILITY_INFO* pInfo) +VK_LAYER_EXPORT VkResult VKAPI vkGetMultiGpuCompatibility(VkPhysicalGpu gpu0, VkPhysicalGpu gpu1, VkGpuCompatibilityInfo* pInfo) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu0; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initParamChecker); - VK_RESULT result = nextTable.GetMultiGpuCompatibility((VK_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo); + VkResult result = nextTable.GetMultiGpuCompatibility((VkPhysicalGpu)gpuw->nextObject, gpu1, pInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedMemory(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { char str[1024]; if (!pOpenInfo) { @@ -405,11 +405,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedMemory(VK_DEVICE device, const VK_ME sprintf(str, "Parameter pOpenInfo to function OpenSharedMemory contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore(VK_DEVICE device, const VK_SEMAPHORE_OPEN_INFO* pOpenInfo, VK_SEMAPHORE* pSemaphore) +VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedSemaphore(VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore) { char str[1024]; if (!pOpenInfo) { @@ -420,11 +420,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenSharedSemaphore(VK_DEVICE device, const VK sprintf(str, "Parameter pOpenInfo to function OpenSharedSemaphore contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore); + VkResult result = nextTable.OpenSharedSemaphore(device, pOpenInfo, pSemaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER_MEMORY_OPEN_INFO* pOpenInfo, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerMemory(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkGpuMemory* pMem) { char str[1024]; if (!pOpenInfo) { @@ -435,11 +435,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerMemory(VK_DEVICE device, const VK_PEER sprintf(str, "Parameter pOpenInfo to function OpenPeerMemory contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); + VkResult result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_IMAGE_OPEN_INFO* pOpenInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkGpuMemory* pMem) { char str[1024]; if (!pOpenInfo) { @@ -450,43 +450,43 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkOpenPeerImage(VK_DEVICE device, const VK_PEER_ sprintf(str, "Parameter pOpenInfo to function OpenPeerImage contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); + VkResult result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDestroyObject(VK_OBJECT object) +VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(VkObject object) { - VK_RESULT result = nextTable.DestroyObject(object); + VkResult result = nextTable.DestroyObject(object); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetObjectInfo(VK_BASE_OBJECT object, VK_OBJECT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(VkBaseObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) { char str[1024]; if (!validate_VK_OBJECT_INFO_TYPE(infoType)) { sprintf(str, "Parameter infoType to function GetObjectInfo has invalid value of %i.", (int)infoType); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); + VkResult result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemory(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_MEMORY mem, VK_GPU_SIZE offset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkObject object, uint32_t allocationIdx, VkGpuMemory mem, VkGpuSize offset) { - VK_RESULT result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); + VkResult result = nextTable.BindObjectMemory(object, allocationIdx, mem, offset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindObjectMemoryRange(VK_OBJECT object, uint32_t allocationIdx, VK_GPU_SIZE rangeOffset, VK_GPU_SIZE rangeSize, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset) +VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemoryRange(VkObject object, uint32_t allocationIdx, VkGpuSize rangeOffset, VkGpuSize rangeSize, VkGpuMemory mem, VkGpuSize memOffset) { - VK_RESULT result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); + VkResult result = nextTable.BindObjectMemoryRange(object, allocationIdx, rangeOffset, rangeSize, mem, memOffset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange(VK_IMAGE image, uint32_t allocationIdx, const VK_IMAGE_MEMORY_BIND_INFO* bindInfo, VK_GPU_MEMORY mem, VK_GPU_SIZE memOffset) +VK_LAYER_EXPORT VkResult VKAPI vkBindImageMemoryRange(VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* bindInfo, VkGpuMemory mem, VkGpuSize memOffset) { char str[1024]; if (!bindInfo) { @@ -497,11 +497,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBindImageMemoryRange(VK_IMAGE image, uint32_t sprintf(str, "Parameter bindInfo to function BindImageMemoryRange contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset); + VkResult result = nextTable.BindImageMemoryRange(image, allocationIdx, bindInfo, mem, memOffset); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_CREATE_INFO* pCreateInfo, VK_FENCE* pFence) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) { char str[1024]; if (!pCreateInfo) { @@ -512,32 +512,32 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFence(VK_DEVICE device, const VK_FENCE_C sprintf(str, "Parameter pCreateInfo to function CreateFence contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence); + VkResult result = nextTable.CreateFence(device, pCreateInfo, pFence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFenceStatus(VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(VkFence fence) { - VK_RESULT result = nextTable.GetFenceStatus(fence); + VkResult result = nextTable.GetFenceStatus(fence); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWaitForFences(VK_DEVICE device, uint32_t fenceCount, const VK_FENCE* pFences, bool32_t waitAll, uint64_t timeout) +VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout) { - VK_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); + VkResult result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetFences(VK_DEVICE device, uint32_t fenceCount, VK_FENCE* pFences) +VK_LAYER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, VkFence* pFences) { - VK_RESULT result = nextTable.ResetFences(device, fenceCount, pFences); + VkResult result = nextTable.ResetFences(device, fenceCount, pFences); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEMAPHORE_CREATE_INFO* pCreateInfo, VK_SEMAPHORE* pSemaphore) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) { char str[1024]; if (!pCreateInfo) { @@ -548,25 +548,25 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSemaphore(VK_DEVICE device, const VK_SEM sprintf(str, "Parameter pCreateInfo to function CreateSemaphore contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore); + VkResult result = nextTable.CreateSemaphore(device, pCreateInfo, pSemaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueSignalSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore) +VK_LAYER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) { - VK_RESULT result = nextTable.QueueSignalSemaphore(queue, semaphore); + VkResult result = nextTable.QueueSignalSemaphore(queue, semaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkQueueWaitSemaphore(VK_QUEUE queue, VK_SEMAPHORE semaphore) +VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) { - VK_RESULT result = nextTable.QueueWaitSemaphore(queue, semaphore); + VkResult result = nextTable.QueueWaitSemaphore(queue, semaphore); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_CREATE_INFO* pCreateInfo, VK_EVENT* pEvent) +VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) { char str[1024]; if (!pCreateInfo) { @@ -577,32 +577,32 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateEvent(VK_DEVICE device, const VK_EVENT_C sprintf(str, "Parameter pCreateInfo to function CreateEvent contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent); + VkResult result = nextTable.CreateEvent(device, pCreateInfo, pEvent); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetEventStatus(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkGetEventStatus(VkEvent event) { - VK_RESULT result = nextTable.GetEventStatus(event); + VkResult result = nextTable.GetEventStatus(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkSetEvent(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkSetEvent(VkEvent event) { - VK_RESULT result = nextTable.SetEvent(event); + VkResult result = nextTable.SetEvent(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetEvent(VK_EVENT event) +VK_LAYER_EXPORT VkResult VKAPI vkResetEvent(VkEvent event) { - VK_RESULT result = nextTable.ResetEvent(event); + VkResult result = nextTable.ResetEvent(event); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUERY_POOL_CREATE_INFO* pCreateInfo, VK_QUERY_POOL* pQueryPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) { char str[1024]; if (!pCreateInfo) { @@ -613,18 +613,18 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateQueryPool(VK_DEVICE device, const VK_QUE sprintf(str, "Parameter pCreateInfo to function CreateQueryPool contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); + VkResult result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetQueryPoolResults(VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData) { - VK_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData); + VkResult result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT format, VK_FORMAT_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetFormatInfo(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData) { char str[1024]; if (!validate_VK_FORMAT(format)) { @@ -635,11 +635,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetFormatInfo(VK_DEVICE device, VK_FORMAT form sprintf(str, "Parameter infoType to function GetFormatInfo has invalid value of %i.", (int)infoType); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData); + VkResult result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferCreateInfo* pCreateInfo, VK_BUFFER* pBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) { char str[1024]; if (!pCreateInfo) { @@ -650,11 +650,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBuffer(VK_DEVICE device, const VkBufferC 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); } - VK_RESULT result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); + VkResult result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBufferViewCreateInfo* pCreateInfo, VK_BUFFER_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) { char str[1024]; if (!pCreateInfo) { @@ -665,15 +665,15 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateBufferView(VK_DEVICE device, const VkBuf 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); } - VK_RESULT result = nextTable.CreateBufferView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateBufferView(device, pCreateInfo, pView); return result; } -void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) +void PreCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo) { if(pCreateInfo == nullptr) { - char const str[] = "vkCreateImage parameter, VK_IMAGE_CREATE_INFO* pCreateInfo, is "\ + char const str[] = "vkCreateImage parameter, VkImageCreateInfo* pCreateInfo, is "\ "nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -689,7 +689,7 @@ void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) if (!validate_VK_IMAGE_TYPE(pCreateInfo->imageType)) { - char const str[] = "vkCreateImage parameter, VK_IMAGE_TYPE pCreateInfo->imageType, is "\ + char const str[] = "vkCreateImage parameter, VkImageType pCreateInfo->imageType, is "\ "unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -697,19 +697,19 @@ void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) if (!validate_VK_FORMAT(pCreateInfo->format)) { - char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, is "\ + char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, is "\ "unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } - VK_FORMAT_PROPERTIES properties; + VkFormatProperties properties; size_t size = sizeof(properties); - VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->format, + VkResult result = nextTable.GetFormatInfo(device, pCreateInfo->format, VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties); if(result != VK_SUCCESS) { - char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, cannot be "\ + char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, cannot be "\ "validated (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -717,7 +717,7 @@ void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0)) { - char const str[] = "vkCreateImage parameter, VK_FORMAT pCreateInfo->format, contains "\ + char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, contains "\ "unsupported format (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -726,7 +726,7 @@ void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) // TODO: Can we check device-specific limits? if (!vk_validate_vk_extent3d(&pCreateInfo->extent)) { - char const str[] = "vkCreateImage parameter, VK_EXTENT3D pCreateInfo->extent, is invalid "\ + char const str[] = "vkCreateImage parameter, VkExtent3D pCreateInfo->extent, is invalid "\ "(precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -734,18 +734,18 @@ void PreCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo) if (!validate_VK_IMAGE_TILING(pCreateInfo->tiling)) { - char const str[] = "vkCreateImage parameter, VK_IMAGE_TILING pCreateInfo->tiling, is "\ + char const str[] = "vkCreateImage parameter, VkImageTiling pCreateInfo->tiling, is "\ "unrecoginized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -void PostCreateImage(VK_RESULT result, VK_IMAGE* pImage) +void PostCreateImage(VkResult result, VkImage* pImage) { if(result != VK_SUCCESS) { - // TODO: Spit out VK_RESULT value. + // TODO: Spit out VkResult value. char const str[] = "vkCreateImage failed (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -753,21 +753,21 @@ void PostCreateImage(VK_RESULT result, VK_IMAGE* pImage) if(pImage == nullptr) { - char const str[] = "vkCreateImage parameter, VK_IMAGE* pImage, is nullptr (postcondition)."; + char const str[] = "vkCreateImage parameter, VkImage* pImage, is nullptr (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImage(VK_DEVICE device, const VK_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) { PreCreateImage(device, pCreateInfo); - VK_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage); + VkResult result = nextTable.CreateImage(device, pCreateInfo, pImage); PostCreateImage(result, pImage); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo(VK_IMAGE image, const VK_IMAGE_SUBRESOURCE* pSubresource, VK_SUBRESOURCE_INFO_TYPE infoType, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkGetImageSubresourceInfo(VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData) { char str[1024]; if (!pSubresource) { @@ -782,11 +782,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkGetImageSubresourceInfo(VK_IMAGE image, const sprintf(str, "Parameter infoType to function GetImageSubresourceInfo has invalid value of %i.", (int)infoType); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData); + VkResult result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMAGE_VIEW_CREATE_INFO* pCreateInfo, VK_IMAGE_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) { char str[1024]; if (!pCreateInfo) { @@ -797,11 +797,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateImageView(VK_DEVICE device, const VK_IMA sprintf(str, "Parameter pCreateInfo to function CreateImageView contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateImageView(device, pCreateInfo, pView); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, const VK_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, VK_COLOR_ATTACHMENT_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) { char str[1024]; if (!pCreateInfo) { @@ -812,11 +812,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateColorAttachmentView(VK_DEVICE device, co sprintf(str, "Parameter pCreateInfo to function CreateColorAttachmentView contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const VK_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, VK_DEPTH_STENCIL_VIEW* pView) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) { char str[1024]; if (!pCreateInfo) { @@ -827,11 +827,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDepthStencilView(VK_DEVICE device, const sprintf(str, "Parameter pCreateInfo to function CreateDepthStencilView contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); + VkResult result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER_CREATE_INFO* pCreateInfo, VK_SHADER* pShader) +VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) { char str[1024]; if (!pCreateInfo) { @@ -842,11 +842,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateShader(VK_DEVICE device, const VK_SHADER sprintf(str, "Parameter pCreateInfo to function CreateShader contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader); + VkResult result = nextTable.CreateShader(device, pCreateInfo, pShader); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { char str[1024]; if (!pCreateInfo) { @@ -857,11 +857,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipeline(VK_DEVICE device, const sprintf(str, "Parameter pCreateInfo to function CreateGraphicsPipeline contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(VK_DEVICE device, const VK_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline) { char str[1024]; if (!pCreateInfo) { @@ -872,11 +872,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateGraphicsPipelineDerivative(VK_DEVICE dev sprintf(str, "Parameter pCreateInfo to function CreateGraphicsPipelineDerivative contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); + VkResult result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const VK_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) { char str[1024]; if (!pCreateInfo) { @@ -887,32 +887,32 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateComputePipeline(VK_DEVICE device, const sprintf(str, "Parameter pCreateInfo to function CreateComputePipeline contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); + VkResult result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkStorePipeline(VK_PIPELINE pipeline, size_t* pDataSize, void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkStorePipeline(VkPipeline pipeline, size_t* pDataSize, void* pData) { - VK_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData); + VkResult result = nextTable.StorePipeline(pipeline, pDataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipeline(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkLoadPipeline(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline) { - VK_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline); + VkResult result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkLoadPipelineDerivative(VK_DEVICE device, size_t dataSize, const void* pData, VK_PIPELINE basePipeline, VK_PIPELINE* pPipeline) +VK_LAYER_EXPORT VkResult VKAPI vkLoadPipelineDerivative(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline) { - VK_RESULT result = nextTable.LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline); + VkResult result = nextTable.LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPLER_CREATE_INFO* pCreateInfo, VK_SAMPLER* pSampler) +VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { char str[1024]; if (!pCreateInfo) { @@ -923,11 +923,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateSampler(VK_DEVICE device, const VK_SAMPL sprintf(str, "Parameter pCreateInfo to function CreateSampler contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler); + VkResult result = nextTable.CreateSampler(device, pCreateInfo, pSampler); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_SET_LAYOUT* pSetLayout) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) { char str[1024]; if (!pCreateInfo) { @@ -938,36 +938,36 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayout(VK_DEVICE device, co sprintf(str, "Parameter pCreateInfo to function CreateDescriptorSetLayout contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); + VkResult result = nextTable.CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorSetLayoutChain(VK_DEVICE device, uint32_t setLayoutArrayCount, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayoutArray, VK_DESCRIPTOR_SET_LAYOUT_CHAIN* pLayoutChain) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayoutChain(VkDevice device, uint32_t setLayoutArrayCount, const VkDescriptorSetLayout* pSetLayoutArray, VkDescriptorSetLayoutChain* pLayoutChain) { - VK_RESULT result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain); + VkResult result = nextTable.CreateDescriptorSetLayoutChain(device, setLayoutArrayCount, pSetLayoutArray, pLayoutChain); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginDescriptorPoolUpdate(VK_DEVICE device, VK_DESCRIPTOR_UPDATE_MODE updateMode) +VK_LAYER_EXPORT VkResult VKAPI vkBeginDescriptorPoolUpdate(VkDevice device, VkDescriptorUpdateMode updateMode) { char str[1024]; if (!validate_VK_DESCRIPTOR_UPDATE_MODE(updateMode)) { sprintf(str, "Parameter updateMode to function BeginDescriptorPoolUpdate has invalid value of %i.", (int)updateMode); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); + VkResult result = nextTable.BeginDescriptorPoolUpdate(device, updateMode); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndDescriptorPoolUpdate(VK_DEVICE device, VK_CMD_BUFFER cmd) +VK_LAYER_EXPORT VkResult VKAPI vkEndDescriptorPoolUpdate(VkDevice device, VkCmdBuffer cmd) { - VK_RESULT result = nextTable.EndDescriptorPoolUpdate(device, cmd); + VkResult result = nextTable.EndDescriptorPoolUpdate(device, cmd); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESCRIPTOR_POOL_USAGE poolUsage, uint32_t maxSets, const VK_DESCRIPTOR_POOL_CREATE_INFO* pCreateInfo, VK_DESCRIPTOR_POOL* pDescriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) { char str[1024]; if (!validate_VK_DESCRIPTOR_POOL_USAGE(poolUsage)) { @@ -982,41 +982,41 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDescriptorPool(VK_DEVICE device, VK_DESC sprintf(str, "Parameter pCreateInfo to function CreateDescriptorPool contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); + VkResult result = nextTable.CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetDescriptorPool(VK_DESCRIPTOR_POOL descriptorPool) +VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDescriptorPool descriptorPool) { - VK_RESULT result = nextTable.ResetDescriptorPool(descriptorPool); + VkResult result = nextTable.ResetDescriptorPool(descriptorPool); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkAllocDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, VK_DESCRIPTOR_SET_USAGE setUsage, uint32_t count, const VK_DESCRIPTOR_SET_LAYOUT* pSetLayouts, VK_DESCRIPTOR_SET* pDescriptorSets, uint32_t* pCount) +VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { char str[1024]; if (!validate_VK_DESCRIPTOR_SET_USAGE(setUsage)) { sprintf(str, "Parameter setUsage to function AllocDescriptorSets has invalid value of %i.", (int)setUsage); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); + VkResult result = nextTable.AllocDescriptorSets(descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); return result; } -VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VK_DESCRIPTOR_POOL descriptorPool, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets) +VK_LAYER_EXPORT void VKAPI vkClearDescriptorSets(VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) { nextTable.ClearDescriptorSets(descriptorPool, count, pDescriptorSets); } -VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VK_DESCRIPTOR_SET descriptorSet, uint32_t updateCount, const void** ppUpdateArray) +VK_LAYER_EXPORT void VKAPI vkUpdateDescriptors(VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray) { nextTable.UpdateDescriptors(descriptorSet, updateCount, ppUpdateArray); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, const VK_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_VP_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpStateObject* pState) { char str[1024]; if (!pCreateInfo) { @@ -1027,11 +1027,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicViewportState(VK_DEVICE device, c sprintf(str, "Parameter pCreateInfo to function CreateDynamicViewportState contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, const VK_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_RS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsStateObject* pState) { char str[1024]; if (!pCreateInfo) { @@ -1042,11 +1042,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicRasterState(VK_DEVICE device, con sprintf(str, "Parameter pCreateInfo to function CreateDynamicRasterState contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, const VK_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_CB_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbStateObject* pState) { char str[1024]; if (!pCreateInfo) { @@ -1057,11 +1057,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicColorBlendState(VK_DEVICE device, sprintf(str, "Parameter pCreateInfo to function CreateDynamicColorBlendState contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE device, const VK_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo, VK_DYNAMIC_DS_STATE_OBJECT* pState) +VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsStateObject* pState) { char str[1024]; if (!pCreateInfo) { @@ -1072,15 +1072,15 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateDynamicDepthStencilState(VK_DEVICE devic sprintf(str, "Parameter pCreateInfo to function CreateDynamicDepthStencilState contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); + VkResult result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState); return result; } -void PreCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo) +void PreCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo) { if(device == nullptr) { - char const str[] = "vkCreateCommandBuffer parameter, VK_DEVICE device, is "\ + char const str[] = "vkCreateCommandBuffer parameter, VkDevice device, is "\ "nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1088,7 +1088,7 @@ void PreCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* p if(pCreateInfo == nullptr) { - char const str[] = "vkCreateCommandBuffer parameter, VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, is "\ + char const str[] = "vkCreateCommandBuffer parameter, VkCmdBufferCreateInfo* pCreateInfo, is "\ "nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1103,11 +1103,11 @@ void PreCreateCommandBuffer(VK_DEVICE device, const VK_CMD_BUFFER_CREATE_INFO* p } } -void PostCreateCommandBuffer(VK_RESULT result, VK_CMD_BUFFER* pCmdBuffer) +void PostCreateCommandBuffer(VkResult result, VkCmdBuffer* pCmdBuffer) { if(result != VK_SUCCESS) { - // TODO: Spit out VK_RESULT value. + // TODO: Spit out VkResult value. char const str[] = "vkCreateCommandBuffer failed (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1115,22 +1115,22 @@ void PostCreateCommandBuffer(VK_RESULT result, VK_CMD_BUFFER* pCmdBuffer) if(pCmdBuffer == nullptr) { - char const str[] = "vkCreateCommandBuffer parameter, VK_CMD_BUFFER* pCmdBuffer, is nullptr (postcondition)."; + char const str[] = "vkCreateCommandBuffer parameter, VkCmdBuffer* pCmdBuffer, is nullptr (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateCommandBuffer(VK_DEVICE device, - const VK_CMD_BUFFER_CREATE_INFO* pCreateInfo, VK_CMD_BUFFER* pCmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, + const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) { PreCreateCommandBuffer(device, pCreateInfo); - VK_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); PostCreateCommandBuffer(result, pCmdBuffer); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, const VK_CMD_BUFFER_BEGIN_INFO* pBeginInfo) +VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { char str[1024]; if (!pBeginInfo) { @@ -1141,25 +1141,25 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkBeginCommandBuffer(VK_CMD_BUFFER cmdBuffer, co sprintf(str, "Parameter pBeginInfo to function BeginCommandBuffer contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); + VkResult result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkEndCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer) { - VK_RESULT result = nextTable.EndCommandBuffer(cmdBuffer); + VkResult result = nextTable.EndCommandBuffer(cmdBuffer); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkResetCommandBuffer(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer) { - VK_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer); + VkResult result = nextTable.ResetCommandBuffer(cmdBuffer); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_PIPELINE pipeline) +VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { char str[1024]; if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) { @@ -1169,7 +1169,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(VK_CMD_BUFFER cmdBuffer, VK_PIPELIN nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, VK_STATE_BIND_POINT stateBindPoint, VK_DYNAMIC_STATE_OBJECT state) +VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state) { char str[1024]; if (!validate_VK_STATE_BIND_POINT(stateBindPoint)) { @@ -1179,7 +1179,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VK_CMD_BUFFER cmdBuffer, nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state); } -VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, VK_DESCRIPTOR_SET_LAYOUT_CHAIN layoutChain, uint32_t layoutChainSlot, uint32_t count, const VK_DESCRIPTOR_SET* pDescriptorSets, const uint32_t* pUserData) +VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData) { char str[1024]; if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) { @@ -1189,13 +1189,13 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData); } -VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t binding) +VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding) { nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding); } -VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, VK_INDEX_TYPE indexType) +VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType) { char str[1024]; if (!validate_VK_INDEX_TYPE(indexType)) { @@ -1205,43 +1205,43 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFF nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); } -VK_LAYER_EXPORT void VKAPI vkCmdDraw(VK_CMD_BUFFER cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) { nextTable.CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VK_CMD_BUFFER cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) { nextTable.CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset, uint32_t count, uint32_t stride) +VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride) { nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VK_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z) +VK_LAYER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) { nextTable.CmdDispatch(cmdBuffer, x, y, z); } -VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VK_CMD_BUFFER cmdBuffer, VK_BUFFER buffer, VK_GPU_SIZE offset) +VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset) { nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { char str[1024]; uint32_t i; @@ -1254,7 +1254,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER sr nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) { @@ -1275,7 +1275,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcI nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_IMAGE_BLIT* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) { @@ -1296,7 +1296,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcI nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BUFFER srcBuffer, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(destImageLayout)) { @@ -1313,7 +1313,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(VK_CMD_BUFFER cmdBuffer, VK_BU nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_BUFFER destBuffer, uint32_t regionCount, const VK_BUFFER_IMAGE_COPY* pRegions) +VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) { @@ -1330,7 +1330,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VK_CMD_BUFFER cmdBuffer, VK_IM nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); } -VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout) +VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) { @@ -1344,19 +1344,19 @@ VK_LAYER_EXPORT void VKAPI vkCmdCloneImageData(VK_CMD_BUFFER cmdBuffer, VK_IMAGE nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout); } -VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE dataSize, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize dataSize, const uint32_t* pData) { nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VK_CMD_BUFFER cmdBuffer, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset, VK_GPU_SIZE fillSize, uint32_t data) +VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkGpuSize destOffset, VkGpuSize fillSize, uint32_t data) { nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data); } -VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, VK_CLEAR_COLOR color, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(imageLayout)) { @@ -1373,7 +1373,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(VK_CMD_BUFFER cmdBuffer, VK_IMAG nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IMAGE image, VK_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VK_IMAGE_SUBRESOURCE_RANGE* pRanges) +VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(imageLayout)) { @@ -1390,7 +1390,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(VK_CMD_BUFFER cmdBuffer, VK_IM nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); } -VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE srcImage, VK_IMAGE_LAYOUT srcImageLayout, VK_IMAGE destImage, VK_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const VK_IMAGE_RESOLVE* pRects) +VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t rectCount, const VkImageResolve* pRects) { char str[1024]; if (!validate_VK_IMAGE_LAYOUT(srcImageLayout)) { @@ -1411,7 +1411,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(VK_CMD_BUFFER cmdBuffer, VK_IMAGE s nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects); } -VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { char str[1024]; if (!validate_VK_PIPE_EVENT(pipeEvent)) { @@ -1421,7 +1421,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdSetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT event, VK_PIPE_EVENT pipeEvent) +VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) { char str[1024]; if (!validate_VK_PIPE_EVENT(pipeEvent)) { @@ -1431,7 +1431,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdResetEvent(VK_CMD_BUFFER cmdBuffer, VK_EVENT eve nextTable.CmdResetEvent(cmdBuffer, event, pipeEvent); } -VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVENT_WAIT_INFO* pWaitInfo) +VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, const VkEventWaitInfo* pWaitInfo) { char str[1024]; if (!pWaitInfo) { @@ -1445,7 +1445,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWaitEvents(VK_CMD_BUFFER cmdBuffer, const VK_EVE nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo); } -VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const VK_PIPELINE_BARRIER* pBarrier) +VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, const VkPipelineBarrier* pBarrier) { char str[1024]; if (!pBarrier) { @@ -1459,25 +1459,25 @@ VK_LAYER_EXPORT void VKAPI vkCmdPipelineBarrier(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier); } -VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot, VK_FLAGS flags) +VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags); } -VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t slot) +VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) { nextTable.CmdEndQuery(cmdBuffer, queryPool, slot); } -VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VK_CMD_BUFFER cmdBuffer, VK_QUERY_POOL queryPool, uint32_t startQuery, uint32_t queryCount) +VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) { nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); } -VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMESTAMP_TYPE timestampType, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkGpuSize destOffset) { char str[1024]; if (!validate_VK_TIMESTAMP_TYPE(timestampType)) { @@ -1487,7 +1487,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VK_CMD_BUFFER cmdBuffer, VK_TIMES nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) +VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) { char str[1024]; if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) { @@ -1497,7 +1497,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdInitAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData); } -VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER srcBuffer, VK_GPU_SIZE srcOffset) +VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkGpuSize srcOffset) { char str[1024]; if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) { @@ -1507,7 +1507,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset); } -VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_PIPELINE_BIND_POINT pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VK_BUFFER destBuffer, VK_GPU_SIZE destOffset) +VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkGpuSize destOffset) { char str[1024]; if (!validate_VK_PIPELINE_BIND_POINT(pipelineBindPoint)) { @@ -1517,7 +1517,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VK_CMD_BUFFER cmdBuffer, VK_P nextTable.CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_FRAMEBUFFER_CREATE_INFO* pCreateInfo, VK_FRAMEBUFFER* pFramebuffer) +VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) { char str[1024]; if (!pCreateInfo) { @@ -1528,16 +1528,16 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateFramebuffer(VK_DEVICE device, const VK_F sprintf(str, "Parameter pCreateInfo to function CreateFramebuffer contains an invalid value."); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); + VkResult result = nextTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer); return result; } -void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo) +void PreCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo) { if(pCreateInfo == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_RENDER_PASS_CREATE_INFO* pCreateInfo, is "\ + char const str[] = "vkCreateRenderPass parameter, VkRenderPassCreateInfo* pCreateInfo, is "\ "nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1553,7 +1553,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!vk_validate_vk_rect(&pCreateInfo->renderArea)) { - char const str[] = "vkCreateRenderPass parameter, VK_RECT pCreateInfo->renderArea, is invalid "\ + char const str[] = "vkCreateRenderPass parameter, VkRect pCreateInfo->renderArea, is invalid "\ "(precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1561,7 +1561,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!vk_validate_vk_extent2d(&pCreateInfo->extent)) { - char const str[] = "vkCreateRenderPass parameter, VK_EXTENT2D pCreateInfo->extent, is invalid "\ + char const str[] = "vkCreateRenderPass parameter, VkExtent2D pCreateInfo->extent, is invalid "\ "(precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1569,7 +1569,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(pCreateInfo->pColorFormats == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_FORMAT* pCreateInfo->pColorFormats, "\ + char const str[] = "vkCreateRenderPass parameter, VkFormat* pCreateInfo->pColorFormats, "\ "is nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1580,20 +1580,20 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_FORMAT(pCreateInfo->pColorFormats[i])) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i << + ss << "vkCreateRenderPass parameter, VkFormat pCreateInfo->pColorFormats[" << i << "], is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; } - VK_FORMAT_PROPERTIES properties; + VkFormatProperties properties; size_t size = sizeof(properties); - VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->pColorFormats[i], + VkResult result = nextTable.GetFormatInfo(device, pCreateInfo->pColorFormats[i], VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties); if(result != VK_SUCCESS) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i << + ss << "vkCreateRenderPass parameter, VkFormat pCreateInfo->pColorFormats[" << i << "], cannot be validated (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1602,7 +1602,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0)) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->pColorFormats[" << i << + ss << "vkCreateRenderPass parameter, VkFormat pCreateInfo->pColorFormats[" << i << "], contains unsupported format (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1612,7 +1612,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(pCreateInfo->pColorLayouts == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT* pCreateInfo->pColorLayouts, "\ + char const str[] = "vkCreateRenderPass parameter, VkImageLayout* pCreateInfo->pColorLayouts, "\ "is nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1623,7 +1623,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_IMAGE_LAYOUT(pCreateInfo->pColorLayouts[i])) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT pCreateInfo->pColorLayouts[" << i << + ss << "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pColorLayouts[" << i << "], is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1632,7 +1632,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(pCreateInfo->pColorLoadOps == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP* pCreateInfo->pColorLoadOps, "\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentLoadOp* pCreateInfo->pColorLoadOps, "\ "is nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1643,7 +1643,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->pColorLoadOps[i])) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->pColorLoadOps[" << i << + ss << "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->pColorLoadOps[" << i << "], is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1652,7 +1652,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(pCreateInfo->pColorStoreOps == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP* pCreateInfo->pColorStoreOps, "\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentStoreOp* pCreateInfo->pColorStoreOps, "\ "is nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1663,7 +1663,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->pColorStoreOps[i])) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->pColorStoreOps[" << i << + ss << "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->pColorStoreOps[" << i << "], is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1672,7 +1672,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(pCreateInfo->pColorLoadClearValues == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_CLEAR_COLOR* pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkClearColor* pCreateInfo->"\ "pColorLoadClearValues, is nullptr (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1711,7 +1711,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!vk_validate_vk_clear_color(&(pCreateInfo->pColorLoadClearValues[i]))) { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VK_CLEAR_COLOR pCreateInfo->pColorLoadClearValues[" << i << + ss << "vkCreateRenderPass parameter, VkClearColor pCreateInfo->pColorLoadClearValues[" << i << "], is invalid (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", ss.str().c_str()); continue; @@ -1720,19 +1720,19 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_FORMAT(pCreateInfo->depthStencilFormat)) { - char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkFormat pCreateInfo->"\ "depthStencilFormat, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } - VK_FORMAT_PROPERTIES properties; + VkFormatProperties properties; size_t size = sizeof(properties); - VK_RESULT result = nextTable.GetFormatInfo(device, pCreateInfo->depthStencilFormat, + VkResult result = nextTable.GetFormatInfo(device, pCreateInfo->depthStencilFormat, VK_INFO_TYPE_FORMAT_PROPERTIES, &size, &properties); if(result != VK_SUCCESS) { - char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkFormat pCreateInfo->"\ "depthStencilFormat, cannot be validated (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1740,7 +1740,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0)) { - char const str[] = "vkCreateRenderPass parameter, VK_FORMAT pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkFormat pCreateInfo->"\ "depthStencilFormat, contains unsupported format (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1748,7 +1748,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_IMAGE_LAYOUT(pCreateInfo->depthStencilLayout)) { - char const str[] = "vkCreateRenderPass parameter, VK_IMAGE_LAYOUT pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->"\ "depthStencilLayout, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1756,7 +1756,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->depthLoadOp)) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->"\ "depthLoadOp, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1764,7 +1764,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->depthStoreOp)) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->"\ "depthStoreOp, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1772,7 +1772,7 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_LOAD_OP(pCreateInfo->stencilLoadOp)) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_LOAD_OP pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->"\ "stencilLoadOp, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1780,18 +1780,18 @@ void PreCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCr if(!validate_VK_ATTACHMENT_STORE_OP(pCreateInfo->stencilStoreOp)) { - char const str[] = "vkCreateRenderPass parameter, VK_ATTACHMENT_STORE_OP pCreateInfo->"\ + char const str[] = "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->"\ "stencilStoreOp, is unrecognized (precondition)."; layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -void PostCreateRenderPass(VK_RESULT result, VK_RENDER_PASS* pRenderPass) +void PostCreateRenderPass(VkResult result, VkRenderPass* pRenderPass) { if(result != VK_SUCCESS) { - // TODO: Spit out VK_RESULT value. + // TODO: Spit out VkResult value. char const str[] = "vkCreateRenderPass failed (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; @@ -1799,21 +1799,21 @@ void PostCreateRenderPass(VK_RESULT result, VK_RENDER_PASS* pRenderPass) if(pRenderPass == nullptr) { - char const str[] = "vkCreateRenderPass parameter, VK_RENDER_PASS* pRenderPass, is nullptr (postcondition)."; + char const str[] = "vkCreateRenderPass parameter, VkRenderPass* pRenderPass, is nullptr (postcondition)."; layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); return; } } -VK_LAYER_EXPORT VK_RESULT VKAPI vkCreateRenderPass(VK_DEVICE device, const VK_RENDER_PASS_CREATE_INFO* pCreateInfo, VK_RENDER_PASS* pRenderPass) +VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) { PreCreateRenderPass(device, pCreateInfo); - VK_RESULT result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); + VkResult result = nextTable.CreateRenderPass(device, pCreateInfo, pRenderPass); PostCreateRenderPass(result, pRenderPass); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const VK_RENDER_PASS_BEGIN* pRenderPassBegin) +VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin) { char str[1024]; if (!pRenderPassBegin) { @@ -1827,24 +1827,24 @@ VK_LAYER_EXPORT void VKAPI vkCmdBeginRenderPass(VK_CMD_BUFFER cmdBuffer, const V nextTable.CmdBeginRenderPass(cmdBuffer, pRenderPassBegin); } -VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VK_CMD_BUFFER cmdBuffer, VK_RENDER_PASS renderPass) +VK_LAYER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer, VkRenderPass renderPass) { nextTable.CmdEndRenderPass(cmdBuffer, renderPass); } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetValidationLevel(VK_DEVICE device, VK_VALIDATION_LEVEL validationLevel) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetValidationLevel(VkDevice device, VkValidationLevel validationLevel) { char str[1024]; if (!validate_VK_VALIDATION_LEVEL(validationLevel)) { sprintf(str, "Parameter validationLevel to function DbgSetValidationLevel has invalid value of %i.", (int)validationLevel); layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str); } - VK_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel); + VkResult result = nextTable.DbgSetValidationLevel(device, validationLevel); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) { // This layer intercepts callbacks VK_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (VK_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(VK_LAYER_DBG_FUNCTION_NODE)); @@ -1858,11 +1858,11 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgRegisterMsgCallback(VK_INSTANCE instance, V if (g_actionIsDefault) { g_debugAction = VK_DBG_LAYER_ACTION_CALLBACK; } - VK_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); + VkResult result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) +VK_LAYER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) { VK_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead; VK_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav; @@ -1884,45 +1884,45 @@ VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgUnregisterMsgCallback(VK_INSTANCE instance, else g_debugAction = (VK_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)VK_DBG_LAYER_ACTION_CALLBACK)); } - VK_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); + VkResult result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetMessageFilter(VK_DEVICE device, int32_t msgCode, VK_DBG_MSG_FILTER filter) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetMessageFilter(VkDevice device, int32_t msgCode, VK_DBG_MSG_FILTER filter) { - VK_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter); + VkResult result = nextTable.DbgSetMessageFilter(device, msgCode, filter); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetObjectTag(VK_BASE_OBJECT object, size_t tagSize, const void* pTag) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkBaseObject object, size_t tagSize, const void* pTag) { - VK_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag); + VkResult result = nextTable.DbgSetObjectTag(object, tagSize, pTag); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetGlobalOption(VK_INSTANCE instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetGlobalOption(VkInstance instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) { - VK_RESULT result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData); + VkResult result = nextTable.DbgSetGlobalOption(instance, dbgOption, dataSize, pData); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkDbgSetDeviceOption(VK_DEVICE device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData) +VK_LAYER_EXPORT VkResult VKAPI vkDbgSetDeviceOption(VkDevice device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData) { - VK_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData); + VkResult result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData); return result; } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VK_CMD_BUFFER cmdBuffer, const char* pMarker) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker) { nextTable.CmdDbgMarkerBegin(cmdBuffer, pMarker); } -VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer) +VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer) { nextTable.CmdDbgMarkerEnd(cmdBuffer); @@ -1930,41 +1930,41 @@ VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VK_CMD_BUFFER cmdBuffer) #if defined(__linux__) || defined(XCB_NVIDIA) -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11AssociateConnection(VK_PHYSICAL_GPU gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11AssociateConnection(VkPhysicalGpu gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; pCurObj = gpuw; loader_platform_thread_once(&tabOnce, initParamChecker); - VK_RESULT result = nextTable.WsiX11AssociateConnection((VK_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo); + VkResult result = nextTable.WsiX11AssociateConnection((VkPhysicalGpu)gpuw->nextObject, pConnectionInfo); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11GetMSC(VK_DEVICE device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11GetMSC(VkDevice device, xcb_window_t window, xcb_randr_crtc_t crtc, uint64_t* pMsc) { - VK_RESULT result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc); + VkResult result = nextTable.WsiX11GetMSC(device, window, crtc, pMsc); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11CreatePresentableImage(VK_DEVICE device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VK_IMAGE* pImage, VK_GPU_MEMORY* pMem) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11CreatePresentableImage(VkDevice device, const VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, VkImage* pImage, VkGpuMemory* pMem) { - VK_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); + VkResult result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem); return result; } -VK_LAYER_EXPORT VK_RESULT VKAPI vkWsiX11QueuePresent(VK_QUEUE queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VK_FENCE fence) +VK_LAYER_EXPORT VkResult VKAPI vkWsiX11QueuePresent(VkQueue queue, const VK_WSI_X11_PRESENT_INFO* pPresentInfo, VkFence fence) { - VK_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); + VkResult result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence); return result; } #endif #include "vk_generic_intercept_proc_helper.h" -VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcName) +VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName) { VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu; void* addr; @@ -1979,7 +1979,7 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VK_PHYSICAL_GPU gpu, const char* funcN else { if (gpuw->pGPA == NULL) return NULL; - return gpuw->pGPA((VK_PHYSICAL_GPU)gpuw->nextObject, funcName); + return gpuw->pGPA((VkPhysicalGpu)gpuw->nextObject, funcName); } } -- cgit v1.2.3