From a8fe78a9564106610d2de75d8a5a523caa296281 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Tue, 27 Oct 2015 18:04:07 +0800 Subject: bug 14921 part 1: sed renames Workaround header bug (ALLOC_INFO vs AllocateInfo) in vk_helper.py. This affects the debug extensions as well. s/NONDISP/NON_DISPATCHABLE/g s/CmdBuffer/CommandBuffer/g s/cmdBuffer/commandBuffer/g s/CMD_BUFFER/COMMAND_BUFFER/g s/AllocMemory/AllocateMemory/g s/AllocDescriptorSets/AllocateDescriptorSets/g s/AllocCommandBuffers/AllocateCommandBuffers/g s/VkAllocCallbacks/VkAllocationCallbacks/g s/VkSystemAllocScope/VkSystemAllocationScope/g s/allocScope/allocationScope/g s/allocType/allocationType/g s/pfnAlloc\b/pfnAllocation/g s/pfnRealloc\b/pfnReallocation/g s/VK_SYSTEM_ALLOC_/VK_SYSTEM_ALLOCATION_/g s/extName/extensionName/g s/implVersion/implementationVersion/g s/pAppInfo/pApplicationInfo/g s/pMem\b/pMemory/g s/VkMemoryAllocInfo/VkMemoryAllocateInfo/g s/VkDescriptorSetAllocInfo/VkDescriptorSetAllocateInfo/g s/CmdPool/CommandPool/g s/cmdPool/commandPool/g s/CMD_POOL/COMMAND_POOL/g s/VkCommandBufferAllocInfo/VkCommandBufferAllocateInfo/g s/maxTessellationGenLevel/maxTessellationGenerationLevel/g s/maxFragmentDualSourceAttachments/maxFragmentDualSrcAttachments/g s/destSubpass/dstSubpass/g s/destStageMask/dstStageMask/g s/dualSourceBlend/dualSrcBlend/g s/destBlendColor/dstBlendColor/g s/destBlendAlpha/dstBlendAlpha/g s/VK_FORMAT_NUM/VK_FORMAT_RANGE_SIZE/g s/VK_DYNAMIC_STATE_NUM/VK_DYNAMIC_STATE_RANGE_SIZE/g s/pAppName/pApplicationName/g s/appVersion/applicationVersion/g s/numLevels/levelCount/g s/numLayers/layerCount/g s/destOffset/dstOffset/g s/destSubresource/dstSubresource/g s/VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL/VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL/g s/VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL/VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL/g s/VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT/VK_IMAGE_USAGE_TRANSFER_SRC_BIT/g s/VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT/VK_IMAGE_USAGE_TRANSFER_DST_BIT/g s/destBuffer/dstBuffer/g s/destQueueFamilyIndex/dstQueueFamilyIndex/g s/destSet/dstSet/g s/destBinding/dstBinding/g s/destArrayElement/dstArrayElement/g s/VK_BLEND_DEST_COLOR/VK_BLEND_DST_COLOR/g s/VK_BLEND_ONE_MINUS_DEST_COLOR/VK_BLEND_ONE_MINUS_DST_COLOR/g s/VK_BLEND_DEST_ALPHA/VK_BLEND_DST_ALPHA/g s/VK_BLEND_ONE_MINUS_DEST_ALPHA/VK_BLEND_ONE_MINUS_DST_ALPHA/g s/VK_FORMAT_FEATURE_BLIT_SOURCE_BIT/VK_FORMAT_FEATURE_BLIT_SRC_BIT/g s/VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT/VK_FORMAT_FEATURE_BLIT_DST_BIT/g s/VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT/VK_BUFFER_USAGE_TRANSFER_SRC_BIT/g s/VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT/VK_BUFFER_USAGE_TRANSFER_DST_BIT/g s/VK_COMPARE_OP_LESS_EQUAL/VK_COMPARE_OP_LESS_OR_EQUAL/g s/VK_COMPARE_OP_GREATER_EQUAL/VK_COMPARE_OP_GREATER_OR_EQUAL/g s/VkPipelineRasterStateCreateInfo/VkPipelineRasterizationStateCreateInfo/g s/rasterSamples/rasterizationSamples/g s/pRasterState/pRasterizationState/g s/VK_FRONT_FACE_CCW/VK_FRONT_FACE_COUNTER_CLOCKWISE/g s/VK_FRONT_FACE_CW/VK_FRONT_FACE_CLOCKWISE/g s/VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ/VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY/g s/VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ/VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY/g s/VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ/VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY/g s/VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ/VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY/g s/VK_STENCIL_OP_INC_CLAMP/VK_STENCIL_OP_INCREMENT_AND_CLAMP/g s/VK_STENCIL_OP_DEC_CLAMP/VK_STENCIL_OP_DECREMENT_AND_CLAMP/g s/VK_STENCIL_OP_INC_WRAP/VK_STENCIL_OP_INCREMENT_AND_WRAP/g s/VK_STENCIL_OP_DEC_WRAP/VK_STENCIL_OP_DECREMENT_AND_WRAP/g s/VK_LOGIC_OP_NOOP/VK_LOGIC_OP_NO_OP/g s/VK_LOGIC_OP_EQUIV\b/VK_LOGIC_OP_EQUIVALENT/g s/memBarrierCount/memoryBarrierCount/g s/ppMemBarriers/ppMemoryBarriers/g s/destImage/dstImage/g s/destImageLayout/dstImageLayout/g s/destCache/dstCache/g s/memOffset/memoryOffset/g s/vk_print_vkmemoryallocinfo/vk_print_vkmemoryallocateinfo/g s/pAllocInfo/pAllocateInfo/g s/memRangeCount/memoryRangeCount/g s/pMemRanges/pMemoryRanges/g s/VK_IMAGE_TYPE_NUM/VK_IMAGE_TYPE_RANGE_SIZE/g s/VK_PIPELINE_BIND_POINT_NUM/VK_PIPELINE_BIND_POINT_RANGE_SIZE/g s/vk_size_vkdescriptorsetallocinfo/vk_size_vkdescriptorsetallocateinfo/g s/remap_cmdbuffers/remap_commandbuffers/g s/remap_cmdpool/remap_commandpool/g s/add_to_cmdbuffers_map/add_to_commandbuffers_map/g https://cvs.khronos.org/bugzilla/show_bug.cgi?id=14921 a --- loader/debug_report.c | 4 +- loader/gpa_helper.h | 16 +- loader/loader.c | 118 ++++++------ loader/loader.h | 14 +- loader/table_ops.h | 18 +- loader/trampoline.c | 424 +++++++++++++++++++++---------------------- loader/vk-loader-generate.py | 2 +- loader/wsi_swapchain.c | 2 +- 8 files changed, 299 insertions(+), 299 deletions(-) (limited to 'loader') diff --git a/loader/debug_report.c b/loader/debug_report.c index c1cca4f1..88c3fb05 100644 --- a/loader/debug_report.c +++ b/loader/debug_report.c @@ -42,7 +42,7 @@ typedef void (VKAPI *PFN_stringCallback)(char *message); static const VkExtensionProperties debug_report_extension_info = { - .extName = VK_DEBUG_REPORT_EXTENSION_NAME, + .extensionName = VK_DEBUG_REPORT_EXTENSION_NAME, .specVersion = VK_DEBUG_REPORT_EXTENSION_REVISION, }; @@ -74,7 +74,7 @@ static VkResult debug_report_DbgCreateMsgCallback( void* pUserData, VkDbgMsgCallback* pMsgCallback) { - VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *) loader_heap_alloc((struct loader_instance *)instance, sizeof(VkLayerDbgFunctionNode), VK_SYSTEM_ALLOC_SCOPE_OBJECT); + VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *) loader_heap_alloc((struct loader_instance *)instance, sizeof(VkLayerDbgFunctionNode), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!pNewDbgFuncNode) return VK_ERROR_OUT_OF_HOST_MEMORY; diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h index f572c364..995d4f5f 100644 --- a/loader/gpa_helper.h +++ b/loader/gpa_helper.h @@ -73,8 +73,8 @@ static inline void* globalGetProcAddr(const char *name) return (void*) vkQueueWaitIdle; if (!strcmp(name, "DeviceWaitIdle")) return (void*) vkDeviceWaitIdle; - if (!strcmp(name, "AllocMemory")) - return (void*) vkAllocMemory; + if (!strcmp(name, "AllocateMemory")) + return (void*) vkAllocateMemory; if (!strcmp(name, "FreeMemory")) return (void*) vkFreeMemory; if (!strcmp(name, "MapMemory")) @@ -189,8 +189,8 @@ static inline void* globalGetProcAddr(const char *name) return (void*) vkDestroyDescriptorPool; if (!strcmp(name, "ResetDescriptorPool")) return (void*) vkResetDescriptorPool; - if (!strcmp(name, "AllocDescriptorSets")) - return (void*) vkAllocDescriptorSets; + if (!strcmp(name, "AllocateDescriptorSets")) + return (void*) vkAllocateDescriptorSets; if (!strcmp(name, "FreeDescriptorSets")) return (void*) vkFreeDescriptorSets; if (!strcmp(name, "UpdateDescriptorSets")) @@ -211,8 +211,8 @@ static inline void* globalGetProcAddr(const char *name) return (void*) vkDestroyCommandPool; if (!strcmp(name, "ResetCommandPool")) return (void*) vkResetCommandPool; - if (!strcmp(name, "AllocCommandBuffers")) - return (void*) vkAllocCommandBuffers; + if (!strcmp(name, "AllocateCommandBuffers")) + return (void*) vkAllocateCommandBuffers; if (!strcmp(name, "FreeCommandBuffers")) return (void*) vkFreeCommandBuffers; if (!strcmp(name, "BeginCommandBuffer")) @@ -356,8 +356,8 @@ static inline void *loader_non_passthrough_gdpa(const char *name) return (void*) vkDestroyDevice; if (!strcmp(name, "GetDeviceQueue")) return (void*) vkGetDeviceQueue; - if (!strcmp(name, "AllocCommandBuffers")) - return (void*) vkAllocCommandBuffers; + if (!strcmp(name, "AllocateCommandBuffers")) + return (void*) vkAllocateCommandBuffers; return NULL; } diff --git a/loader/loader.c b/loader/loader.c index 53fdbf37..c1ae2933 100644 --- a/loader/loader.c +++ b/loader/loader.c @@ -111,63 +111,63 @@ LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_init); void* loader_heap_alloc( const struct loader_instance *instance, size_t size, - VkSystemAllocScope alloc_scope) + VkSystemAllocationScope alloc_scope) { - if (instance && instance->alloc_callbacks.pfnAlloc) { + if (instance && instance->alloc_callbacks.pfnAllocation) { /* TODO: What should default alignment be? 1, 4, 8, other? */ - return instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_scope); + return instance->alloc_callbacks.pfnAllocation(instance->alloc_callbacks.pUserData, size, 4, alloc_scope); } return malloc(size); } void loader_heap_free( const struct loader_instance *instance, - void *pMem) + void *pMemory) { - if (pMem == NULL) return; + if (pMemory == NULL) return; if (instance && instance->alloc_callbacks.pfnFree) { - instance->alloc_callbacks.pfnFree(instance->alloc_callbacks.pUserData, pMem); + instance->alloc_callbacks.pfnFree(instance->alloc_callbacks.pUserData, pMemory); return; } - free(pMem); + free(pMemory); } void* loader_heap_realloc( const struct loader_instance *instance, - void *pMem, + void *pMemory, size_t orig_size, size_t size, - VkSystemAllocScope alloc_scope) + VkSystemAllocationScope alloc_scope) { - if (pMem == NULL || orig_size == 0) + if (pMemory == NULL || orig_size == 0) return loader_heap_alloc(instance, size, alloc_scope); if (size == 0) { - loader_heap_free(instance, pMem); + loader_heap_free(instance, pMemory); return NULL; } - if (instance && instance->alloc_callbacks.pfnAlloc) { + if (instance && instance->alloc_callbacks.pfnAllocation) { if (size <= orig_size) { - memset(((uint8_t *)pMem) + size, 0, orig_size - size); - return pMem; + memset(((uint8_t *)pMemory) + size, 0, orig_size - size); + return pMemory; } - void *new_ptr = instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_scope); + void *new_ptr = instance->alloc_callbacks.pfnAllocation(instance->alloc_callbacks.pUserData, size, 4, alloc_scope); if (!new_ptr) return NULL; - memcpy(new_ptr, pMem, orig_size); - instance->alloc_callbacks.pfnFree(instance->alloc_callbacks.pUserData, pMem); + memcpy(new_ptr, pMemory, orig_size); + instance->alloc_callbacks.pfnFree(instance->alloc_callbacks.pUserData, pMemory); return new_ptr; } - return realloc(pMem, size); + return realloc(pMemory, size); } void *loader_tls_heap_alloc(size_t size) { - return loader_heap_alloc(tls_instance, size, VK_SYSTEM_ALLOC_SCOPE_FUNCTION); + return loader_heap_alloc(tls_instance, size, VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION); } -void loader_tls_heap_free(void *pMem) +void loader_tls_heap_free(void *pMemory) { - loader_heap_free(tls_instance, pMem); + loader_heap_free(tls_instance, pMemory); } static void loader_log(VkFlags msg_type, int32_t msg_code, @@ -247,11 +247,11 @@ static char *loader_get_registry_files(const struct loader_instance *inst, char while ((rtn_value = RegEnumValue(key, idx++, name, &name_size, NULL, NULL, (LPBYTE) &value, &value_size)) == ERROR_SUCCESS) { if (value_size == sizeof(value) && value == 0) { if (out == NULL) { - out = loader_heap_alloc(inst, total_size, VK_SYSTEM_ALLOC_TYPE_INTERNAL); + out = loader_heap_alloc(inst, total_size, VK_SYSTEM_ALLOCATION_TYPE_INTERNAL); out[0] = '\0'; } else if (strlen(out) + name_size + 1 > total_size) { - out = loader_heap_realloc(inst, out, total_size, total_size * 2, VK_SYSTEM_ALLOC_TYPE_INTERNAL); + out = loader_heap_realloc(inst, out, total_size, total_size * 2, VK_SYSTEM_ALLOCATION_TYPE_INTERNAL); total_size *= 2; } if (out == NULL) { @@ -363,7 +363,7 @@ static uint32_t loader_make_version(const char *vers_str) bool compare_vk_extension_properties(const VkExtensionProperties *op1, const VkExtensionProperties *op2) { - return strcmp(op1->extName, op2->extName) == 0 ? true : false; + return strcmp(op1->extensionName, op2->extensionName) == 0 ? true : false; } /** @@ -429,7 +429,7 @@ static struct loader_layer_properties *loader_get_next_layer_property( if (layer_list->capacity == 0) { layer_list->list = loader_heap_alloc(inst, sizeof(struct loader_layer_properties) * 64, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (layer_list->list == NULL) { loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't add any layer properties to list"); return NULL; @@ -444,7 +444,7 @@ static struct loader_layer_properties *loader_get_next_layer_property( layer_list->list = loader_heap_realloc(inst, layer_list->list, layer_list->capacity, layer_list->capacity * 2, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (layer_list->list == NULL) { loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "realloc failed for layer list"); @@ -524,7 +524,7 @@ static void loader_add_global_extensions( VK_PATCH(ext_props[i].specVersion)); loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, "Global Extension: %s (%s) version %s", - ext_props[i].extName, lib_name, spec_version); + ext_props[i].extensionName, lib_name, spec_version); loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]); } @@ -561,7 +561,7 @@ static void loader_add_physical_device_extensions( VK_PATCH(ext_props[i].specVersion)); loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, "PhysicalDevice Extension: %s (%s) version %s", - ext_props[i].extName, lib_name, spec_version); + ext_props[i].extensionName, lib_name, spec_version); loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]); } } else { @@ -575,7 +575,7 @@ static bool loader_init_ext_list(const struct loader_instance *inst, struct loader_extension_list *ext_info) { ext_info->capacity = 32 * sizeof(VkExtensionProperties); - ext_info->list = loader_heap_alloc(inst, ext_info->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + ext_info->list = loader_heap_alloc(inst, ext_info->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (ext_info->list == NULL) { return false; } @@ -629,7 +629,7 @@ void loader_add_to_ext_list( ext_list->list, ext_list->capacity, ext_list->capacity * 2, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); // double capacity ext_list->capacity *= 2; } @@ -676,7 +676,7 @@ static bool loader_init_layer_list(const struct loader_instance *inst, struct loader_layer_list *list) { list->capacity = 32 * sizeof(struct loader_layer_properties); - list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (list->list == NULL) { return false; } @@ -700,7 +700,7 @@ static bool loader_init_layer_library_list(const struct loader_instance *inst, struct loader_layer_library_list *list) { list->capacity = 32 * sizeof(struct loader_lib_info); - list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (list->list == NULL) { return false; } @@ -755,7 +755,7 @@ void loader_add_to_layer_library_list( list->list, list->capacity, list->capacity * 2, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); // double capacity list->capacity *= 2; } @@ -833,7 +833,7 @@ void loader_add_to_layer_list( list->list, list->capacity, list->capacity * 2, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); // double capacity list->capacity *= 2; } @@ -877,7 +877,7 @@ static VkExtensionProperties *get_extension_property( const struct loader_extension_list *list) { for (uint32_t i = 0; i < list->count; i++) { - if (strcmp(name, list->list[i].extName) == 0) + if (strcmp(name, list->list[i].extensionName) == 0) return &list->list[i]; } return NULL; @@ -958,7 +958,7 @@ static struct loader_device *loader_add_logical_device( { struct loader_device *new_dev; - new_dev = loader_heap_alloc(inst, sizeof(struct loader_device), VK_SYSTEM_ALLOC_SCOPE_DEVICE); + new_dev = loader_heap_alloc(inst, sizeof(struct loader_device), VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); if (!new_dev) { loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc struct laoder-device"); return NULL; @@ -1017,7 +1017,7 @@ static struct loader_icd * loader_icd_create(const struct loader_instance *inst) { struct loader_icd *icd; - icd = loader_heap_alloc(inst, sizeof(*icd), VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + icd = loader_heap_alloc(inst, sizeof(*icd), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (!icd) return NULL; @@ -1068,7 +1068,7 @@ static void loader_scanned_icd_init(const struct loader_instance *inst, { loader_scanned_icd_clear(inst, icd_libs); icd_libs->capacity = 8 * sizeof(struct loader_scanned_icds); - icd_libs->list = loader_heap_alloc(inst, icd_libs->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + icd_libs->list = loader_heap_alloc(inst, icd_libs->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); } @@ -1113,7 +1113,7 @@ static void loader_scanned_icd_add( icd_libs->list, icd_libs->capacity, icd_libs->capacity * 2, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); // double capacity icd_libs->capacity *= 2; } @@ -1126,7 +1126,7 @@ static void loader_scanned_icd_add( new_node->lib_name = (char *) loader_heap_alloc(inst, strlen(filename) + 1, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (!new_node->lib_name) { loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Out of memory can't add icd"); return; @@ -1376,7 +1376,7 @@ static void loader_copy_layer_properties( inst, sizeof(VkExtensionProperties) * src->instance_extension_list.count, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); dst->instance_extension_list.capacity = sizeof(VkExtensionProperties) * src->instance_extension_list.count; memcpy(dst->instance_extension_list.list, src->instance_extension_list.list, @@ -1385,7 +1385,7 @@ static void loader_copy_layer_properties( inst, sizeof(VkExtensionProperties) * src->device_extension_list.count, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); dst->device_extension_list.capacity = sizeof(VkExtensionProperties) * src->device_extension_list.count; memcpy(dst->device_extension_list.list, src->device_extension_list.list, @@ -1532,7 +1532,7 @@ static void loader_add_layer_properties(const struct loader_instance *inst, loader_get_fullpath(library_path, DEFAULT_VK_LAYERS_PATH, MAX_STRING_SIZE, fullpath); } props->info.specVersion = loader_make_version(abi_versions); - props->info.implVersion = loader_make_version(implementation_version); + props->info.implementationVersion = loader_make_version(implementation_version); strncpy((char *) props->info.description, description, sizeof (props->info.description)); props->info.description[sizeof (props->info.description) - 1] = '\0'; if (is_implicit) { @@ -1583,8 +1583,8 @@ static void loader_add_layer_properties(const struct loader_instance *inst, ext_item = cJSON_GetArrayItem(instance_extensions, i); GET_JSON_ITEM(ext_item, name) GET_JSON_ITEM(ext_item, version) - strncpy(ext_prop.extName, name, sizeof (ext_prop.extName)); - ext_prop.extName[sizeof (ext_prop.extName) - 1] = '\0'; + strncpy(ext_prop.extensionName, name, sizeof (ext_prop.extensionName)); + ext_prop.extensionName[sizeof (ext_prop.extensionName) - 1] = '\0'; ext_prop.specVersion = loader_make_version(version); loader_add_to_ext_list(inst, &props->instance_extension_list, 1, &ext_prop); } @@ -1596,8 +1596,8 @@ static void loader_add_layer_properties(const struct loader_instance *inst, ext_item = cJSON_GetArrayItem(device_extensions, i); GET_JSON_ITEM(ext_item, name); GET_JSON_ITEM(ext_item, version); - strncpy(ext_prop.extName, name, sizeof (ext_prop.extName)); - ext_prop.extName[sizeof (ext_prop.extName) - 1] = '\0'; + strncpy(ext_prop.extensionName, name, sizeof (ext_prop.extensionName)); + ext_prop.extensionName[sizeof (ext_prop.extensionName) - 1] = '\0'; ext_prop.specVersion = loader_make_version(version); loader_add_to_ext_list(inst, &props->device_extension_list, 1, &ext_prop); } @@ -1759,14 +1759,14 @@ static void loader_get_manifest_files(const struct loader_instance *inst, if (out_files->count == 0) { out_files->filename_list = loader_heap_alloc(inst, alloced_count * sizeof(char *), - VK_SYSTEM_ALLOC_SCOPE_FUNCTION); + VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION); } else if (out_files->count == alloced_count) { out_files->filename_list = loader_heap_realloc(inst, out_files->filename_list, alloced_count * sizeof(char *), alloced_count * sizeof(char *) * 2, - VK_SYSTEM_ALLOC_SCOPE_FUNCTION); + VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION); alloced_count *= 2; } if (out_files->filename_list == NULL) { @@ -1776,7 +1776,7 @@ static void loader_get_manifest_files(const struct loader_instance *inst, out_files->filename_list[out_files->count] = loader_heap_alloc( inst, strlen(name) + 1, - VK_SYSTEM_ALLOC_SCOPE_FUNCTION); + VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION); if (out_files->filename_list[out_files->count] == NULL) { loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files"); return; @@ -2073,7 +2073,7 @@ static loader_platform_dl_handle loader_add_layer_lib( inst, loader.loaded_layer_lib_list, loader.loaded_layer_lib_capacity, new_alloc_size, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (!new_layer_lib_list) { loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "loader: realloc failed in loader_add_layer_lib"); return NULL; @@ -2135,7 +2135,7 @@ static void loader_remove_layer_lib( /* Need to remove unused library from list */ new_layer_lib_list = loader_heap_alloc(inst, loader.loaded_layer_lib_capacity, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (!new_layer_lib_list) { loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "loader: heap alloc failed loader_remove_layer_library"); return; @@ -2415,7 +2415,7 @@ static VkResult loader_enable_device_layers( static VkResult VKAPI scratch_vkCreateDevice( VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocCallbacks* pAllocator, + const VkAllocationCallbacks* pAllocator, VkDevice *pDevice) { return VK_SUCCESS; @@ -2457,7 +2457,7 @@ static uint32_t loader_activate_device_layers( wrappedGpus = loader_heap_alloc(inst, sizeof (VkBaseLayerObject) * dev->activated_layer_list.count, - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (!wrappedGpus) { loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc Gpu objects for layer"); return 0; @@ -2613,7 +2613,7 @@ VkResult loader_validate_device_extensions( VkResult VKAPI loader_CreateInstance( const VkInstanceCreateInfo* pCreateInfo, - const VkAllocCallbacks* pAllocator, + const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { struct loader_instance *ptr_instance = *(struct loader_instance **) pInstance; @@ -2627,7 +2627,7 @@ VkResult VKAPI loader_CreateInstance( icd_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; icd_create_info.enabledLayerNameCount = 0; icd_create_info.ppEnabledLayerNames = NULL; - icd_create_info.pAppInfo = pCreateInfo->pAppInfo; + icd_create_info.pApplicationInfo = pCreateInfo->pApplicationInfo; icd_create_info.pNext = pCreateInfo->pNext; /* @@ -2693,7 +2693,7 @@ VkResult VKAPI loader_CreateInstance( void VKAPI loader_DestroyInstance( VkInstance instance, - const VkAllocCallbacks* pAllocator) + const VkAllocationCallbacks* pAllocator) { struct loader_instance *ptr_instance = loader_instance(instance); struct loader_icd *icds = ptr_instance->icds; @@ -2757,7 +2757,7 @@ VkResult loader_init_physical_device_info( icd->gpus = (VkPhysicalDevice *) loader_heap_alloc( ptr_instance, n * sizeof(VkPhysicalDevice), - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (!icd->gpus) { /* TODO: Add cleanup code here */ return VK_ERROR_OUT_OF_HOST_MEMORY; @@ -2930,7 +2930,7 @@ void VKAPI loader_GetPhysicalDeviceSparseImageFormatProperties( VkResult VKAPI loader_CreateDevice( VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, - const VkAllocCallbacks* pAllocator, + const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { uint32_t gpu_index; diff --git a/loader/loader.h b/loader/loader.h index 96dd2773..2e64e4b8 100644 --- a/loader/loader.h +++ b/loader/loader.h @@ -181,7 +181,7 @@ struct loader_instance { bool debug_report_enabled; VkLayerDbgFunctionNode *DbgFunctionHead; - VkAllocCallbacks alloc_callbacks; + VkAllocationCallbacks alloc_callbacks; bool wsi_swapchain_enabled; }; @@ -265,12 +265,12 @@ VkResult loader_validate_instance_extensions( /* instance layer chain termination entrypoint definitions */ VkResult VKAPI loader_CreateInstance( const VkInstanceCreateInfo* pCreateInfo, - const VkAllocCallbacks* pAllocator, + const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); void VKAPI loader_DestroyInstance( VkInstance instance, - const VkAllocCallbacks* pAllocator); + const VkAllocationCallbacks* pAllocator); VkResult VKAPI loader_EnumeratePhysicalDevices( VkInstance instance, @@ -328,7 +328,7 @@ void VKAPI loader_GetPhysicalDeviceMemoryProperties ( VkResult VKAPI loader_CreateDevice( VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, - const VkAllocCallbacks* pAllocator, + const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); /* helper function definitions */ @@ -393,13 +393,13 @@ void loader_activate_instance_layer_extensions(struct loader_instance *inst); void* loader_heap_alloc( const struct loader_instance *instance, size_t size, - VkSystemAllocScope allocScope); + VkSystemAllocationScope allocationScope); void loader_heap_free( const struct loader_instance *instance, - void *pMem); + void *pMemory); void *loader_tls_heap_alloc(size_t size); -void loader_tls_heap_free(void *pMem); +void loader_tls_heap_free(void *pMemory); #endif /* LOADER_H */ diff --git a/loader/table_ops.h b/loader/table_ops.h index d4a167e7..29bdc389 100644 --- a/loader/table_ops.h +++ b/loader/table_ops.h @@ -43,7 +43,7 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table table->QueueSubmit = (PFN_vkQueueSubmit) gpa(dev, "vkQueueSubmit"); table->QueueWaitIdle = (PFN_vkQueueWaitIdle) gpa(dev, "vkQueueWaitIdle"); table->DeviceWaitIdle = (PFN_vkDeviceWaitIdle) gpa(dev, "vkDeviceWaitIdle"); - table->AllocMemory = (PFN_vkAllocMemory) gpa(dev, "vkAllocMemory"); + table->AllocateMemory = (PFN_vkAllocateMemory) gpa(dev, "vkAllocateMemory"); table->FreeMemory = (PFN_vkFreeMemory) gpa(dev, "vkFreeMemory"); table->MapMemory = (PFN_vkMapMemory) gpa(dev, "vkMapMemory"); table->UnmapMemory = (PFN_vkUnmapMemory) gpa(dev, "vkUnmapMemory"); @@ -100,7 +100,7 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table table->CreateDescriptorPool = (PFN_vkCreateDescriptorPool) gpa(dev, "vkCreateDescriptorPool"); table->DestroyDescriptorPool = (PFN_vkDestroyDescriptorPool) gpa(dev, "vkDestroyDescriptorPool"); table->ResetDescriptorPool = (PFN_vkResetDescriptorPool) gpa(dev, "vkResetDescriptorPool"); - table->AllocDescriptorSets = (PFN_vkAllocDescriptorSets) gpa(dev, "vkAllocDescriptorSets"); + table->AllocateDescriptorSets = (PFN_vkAllocateDescriptorSets) gpa(dev, "vkAllocateDescriptorSets"); table->FreeDescriptorSets = (PFN_vkFreeDescriptorSets) gpa(dev, "vkFreeDescriptorSets"); table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) gpa(dev, "vkUpdateDescriptorSets"); table->CreateFramebuffer = (PFN_vkCreateFramebuffer) gpa(dev, "vkCreateFramebuffer"); @@ -111,7 +111,7 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table table->CreateCommandPool = (PFN_vkCreateCommandPool) gpa(dev, "vkCreateCommandPool"); table->DestroyCommandPool = (PFN_vkDestroyCommandPool) gpa(dev, "vkDestroyCommandPool"); table->ResetCommandPool = (PFN_vkResetCommandPool) gpa(dev, "vkResetCommandPool"); - table->AllocCommandBuffers = (PFN_vkAllocCommandBuffers) gpa(dev, "vkAllocCommandBuffers"); + table->AllocateCommandBuffers = (PFN_vkAllocateCommandBuffers) gpa(dev, "vkAllocateCommandBuffers"); table->FreeCommandBuffers = (PFN_vkFreeCommandBuffers) gpa(dev, "vkFreeCommandBuffers"); table->BeginCommandBuffer = (PFN_vkBeginCommandBuffer) gpa(dev, "vkBeginCommandBuffer"); table->EndCommandBuffer = (PFN_vkEndCommandBuffer) gpa(dev, "vkEndCommandBuffer"); @@ -195,8 +195,8 @@ static inline void *loader_lookup_device_dispatch_table( return (void *) table->QueueWaitIdle; if (!strcmp(name, "DeviceWaitIdle")) return (void *) table->DeviceWaitIdle; - if (!strcmp(name, "AllocMemory")) - return (void *) table->AllocMemory; + if (!strcmp(name, "AllocateMemory")) + return (void *) table->AllocateMemory; if (!strcmp(name, "FreeMemory")) return (void *) table->FreeMemory; if (!strcmp(name, "MapMemory")) @@ -309,8 +309,8 @@ static inline void *loader_lookup_device_dispatch_table( return (void *) table->DestroyDescriptorPool; if (!strcmp(name, "ResetDescriptorPool")) return (void *) table->ResetDescriptorPool; - if (!strcmp(name, "AllocDescriptorSets")) - return (void *) table->AllocDescriptorSets; + if (!strcmp(name, "AllocateDescriptorSets")) + return (void *) table->AllocateDescriptorSets; if (!strcmp(name, "FreeDescriptorSets")) return (void *) table->FreeDescriptorSets; if (!strcmp(name, "UpdateDescriptorSets")) @@ -331,8 +331,8 @@ static inline void *loader_lookup_device_dispatch_table( return (void *) table->DestroyCommandPool; if (!strcmp(name, "ResetCommandPool")) return (void *) table->ResetCommandPool; - if (!strcmp(name, "AllocCommandBuffers")) - return (void *) table->AllocCommandBuffers; + if (!strcmp(name, "AllocateCommandBuffers")) + return (void *) table->AllocateCommandBuffers; if (!strcmp(name, "FreeCommandBuffers")) return (void *) table->FreeCommandBuffers; if (!strcmp(name, "BeginCommandBuffer")) diff --git a/loader/trampoline.c b/loader/trampoline.c index 2a240f15..fb863f67 100644 --- a/loader/trampoline.c +++ b/loader/trampoline.c @@ -34,7 +34,7 @@ /* Trampoline entrypoints */ LOADER_EXPORT VkResult VKAPI vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, - const VkAllocCallbacks* pAllocator, + const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { struct loader_instance *ptr_instance = NULL; @@ -43,11 +43,11 @@ LOADER_EXPORT VkResult VKAPI vkCreateInstance( loader_platform_thread_once(&once_init, loader_initialize); if (pAllocator) { - ptr_instance = (struct loader_instance *) pAllocator->pfnAlloc( + ptr_instance = (struct loader_instance *) pAllocator->pfnAllocation( pAllocator->pUserData, sizeof(struct loader_instance), sizeof(VkInstance), - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); } else { ptr_instance = (struct loader_instance *) malloc(sizeof(struct loader_instance)); } @@ -111,7 +111,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateInstance( ptr_instance->disp = loader_heap_alloc( ptr_instance, sizeof(VkLayerInstanceDispatchTable), - VK_SYSTEM_ALLOC_SCOPE_INSTANCE); + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (ptr_instance->disp == NULL) { loader_delete_layer_properties(ptr_instance, &ptr_instance->device_layer_list); @@ -172,7 +172,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateInstance( LOADER_EXPORT void VKAPI vkDestroyInstance( VkInstance instance, - const VkAllocCallbacks* pAllocator) + const VkAllocationCallbacks* pAllocator) { const VkLayerInstanceDispatchTable *disp; struct loader_instance *ptr_instance = NULL; @@ -273,7 +273,7 @@ LOADER_EXPORT void VKAPI vkGetPhysicalDeviceMemoryProperties( LOADER_EXPORT VkResult VKAPI vkCreateDevice( VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, - const VkAllocCallbacks* pAllocator, + const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { VkResult res; @@ -286,7 +286,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateDevice( return res; } -LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; struct loader_device *dev; @@ -366,16 +366,16 @@ LOADER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device) return disp->DeviceWaitIdle(device); } -LOADER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem) +LOADER_EXPORT VkResult VKAPI vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->AllocMemory(device, pAllocInfo, pAllocator, pMem); + return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); } -LOADER_EXPORT void VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -402,22 +402,22 @@ LOADER_EXPORT void VKAPI vkUnmapMemory(VkDevice device, VkDeviceMemory mem) disp->UnmapMemory(device, mem); } -LOADER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) +LOADER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges); + return disp->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); } -LOADER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) +LOADER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges); + return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); } LOADER_EXPORT void VKAPI vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) @@ -492,7 +492,7 @@ LOADER_EXPORT VkResult VKAPI vkQueueBindSparse(VkQueue queue, uint32_t bindInfoC return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); } -LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence) +LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { const VkLayerDispatchTable *disp; @@ -501,7 +501,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateI return disp->CreateFence(device, pCreateInfo, pAllocator, pFence); } -LOADER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -537,7 +537,7 @@ LOADER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCoun return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout); } -LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore) +LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { const VkLayerDispatchTable *disp; @@ -546,7 +546,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphor return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); } -LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -555,7 +555,7 @@ LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semapho disp->DestroySemaphore(device, semaphore, pAllocator); } -LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent) +LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { const VkLayerDispatchTable *disp; @@ -564,7 +564,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateI return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent); } -LOADER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -600,7 +600,7 @@ LOADER_EXPORT VkResult VKAPI vkResetEvent(VkDevice device, VkEvent event) return disp->ResetEvent(device, event); } -LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool) +LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { const VkLayerDispatchTable *disp; @@ -609,7 +609,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoo return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); } -LOADER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -627,7 +627,7 @@ LOADER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool return disp->GetQueryPoolResults(device, queryPool, startQuery, queryCount, dataSize, pData, stride, flags); } -LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer) +LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { const VkLayerDispatchTable *disp; @@ -636,7 +636,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreat return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); } -LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -645,7 +645,7 @@ LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const disp->DestroyBuffer(device, buffer, pAllocator); } -LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView) +LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { const VkLayerDispatchTable *disp; @@ -654,7 +654,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferV return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView); } -LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -663,7 +663,7 @@ LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView buffe disp->DestroyBufferView(device, bufferView, pAllocator); } -LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage) +LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { const VkLayerDispatchTable *disp; @@ -672,7 +672,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateI return disp->CreateImage(device, pCreateInfo, pAllocator, pImage); } -LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -690,7 +690,7 @@ LOADER_EXPORT void VKAPI vkGetImageSubresourceLayout(VkDevice device, VkImage im disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout); } -LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView) +LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { const VkLayerDispatchTable *disp; @@ -699,7 +699,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageVie return disp->CreateImageView(device, pCreateInfo, pAllocator, pView); } -LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -708,7 +708,7 @@ LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageVi disp->DestroyImageView(device, imageView, pAllocator); } -LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShader) +LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShader) { const VkLayerDispatchTable *disp; @@ -717,7 +717,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShade return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader); } -LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -726,7 +726,7 @@ LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule s disp->DestroyShaderModule(device, shaderModule, pAllocator); } -LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader) +LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader) { const VkLayerDispatchTable *disp; @@ -735,7 +735,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreat return disp->CreateShader(device, pCreateInfo, pAllocator, pShader); } -LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -744,7 +744,7 @@ LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const disp->DestroyShader(device, shader, pAllocator); } -LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { const VkLayerDispatchTable *disp; @@ -753,7 +753,7 @@ LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipe return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); } -LOADER_EXPORT void VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -771,16 +771,16 @@ LOADER_EXPORT VkResult VKAPI vkGetPipelineCacheData(VkDevice device, VkPipelineC return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData); } -LOADER_EXPORT VkResult VKAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +LOADER_EXPORT VkResult VKAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches); + return disp->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); } -LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) +LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { const VkLayerDispatchTable *disp; @@ -789,7 +789,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipeli return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); } -LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) +LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { const VkLayerDispatchTable *disp; @@ -798,7 +798,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelin return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); } -LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -807,7 +807,7 @@ LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, disp->DestroyPipeline(device, pipeline, pAllocator); } -LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { const VkLayerDispatchTable *disp; @@ -816,7 +816,7 @@ LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPip return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); } -LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -825,7 +825,7 @@ LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayo disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator); } -LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler) +LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { const VkLayerDispatchTable *disp; @@ -834,7 +834,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCre return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler); } -LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -844,7 +844,7 @@ LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, co } -LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { const VkLayerDispatchTable *disp; @@ -853,7 +853,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); } -LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -862,7 +862,7 @@ LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescrip disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); } -LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { const VkLayerDispatchTable *disp; @@ -871,7 +871,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDes return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); } -LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -890,13 +890,13 @@ LOADER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptor return disp->ResetDescriptorPool(device, descriptorPool, flags); } -LOADER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets) +LOADER_EXPORT VkResult VKAPI vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->AllocDescriptorSets(device, pAllocInfo, pDescriptorSets); + return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); } LOADER_EXPORT VkResult VKAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) @@ -917,7 +917,7 @@ LOADER_EXPORT void VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t descri disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); } -LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { const VkLayerDispatchTable *disp; @@ -926,7 +926,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFrameb return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); } -LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -935,7 +935,7 @@ LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer fra disp->DestroyFramebuffer(device, framebuffer, pAllocator); } -LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass) +LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { const VkLayerDispatchTable *disp; @@ -944,7 +944,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderP return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); } -LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; @@ -962,48 +962,48 @@ LOADER_EXPORT void VKAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPas disp->GetRenderAreaGranularity(device, renderPass, pGranularity); } -LOADER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool) +LOADER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool); + return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); } -LOADER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator) +LOADER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - disp->DestroyCommandPool(device, cmdPool, pAllocator); + disp->DestroyCommandPool(device, commandPool, pAllocator); } -LOADER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) +LOADER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - return disp->ResetCommandPool(device, cmdPool, flags); + return disp->ResetCommandPool(device, commandPool, flags); } -LOADER_EXPORT VkResult VKAPI vkAllocCommandBuffers( +LOADER_EXPORT VkResult VKAPI vkAllocateCommandBuffers( VkDevice device, - const VkCmdBufferAllocInfo* pAllocInfo, - VkCmdBuffer* pCmdBuffers) + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers) { const VkLayerDispatchTable *disp; VkResult res; disp = loader_get_dispatch(device); - res = disp->AllocCommandBuffers(device, pAllocInfo, pCmdBuffers); + res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); if (res == VK_SUCCESS) { - for (uint32_t i =0; i < pAllocInfo->bufferCount; i++) { - if (pCmdBuffers[i]) { - loader_init_dispatch(pCmdBuffers[i], disp); + for (uint32_t i =0; i < pAllocateInfo->bufferCount; i++) { + if (pCommandBuffers[i]) { + loader_init_dispatch(pCommandBuffers[i], disp); } } } @@ -1013,436 +1013,436 @@ LOADER_EXPORT VkResult VKAPI vkAllocCommandBuffers( LOADER_EXPORT void VKAPI vkFreeCommandBuffers( VkDevice device, - VkCmdPool cmdPool, + VkCommandPool commandPool, uint32_t commandBufferCount, - const VkCmdBuffer* pCommandBuffers) + const VkCommandBuffer* pCommandBuffers) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); - disp->FreeCommandBuffers(device, cmdPool, commandBufferCount, pCommandBuffers); + disp->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); } -LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) +LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - return disp->BeginCommandBuffer(cmdBuffer, pBeginInfo); + return disp->BeginCommandBuffer(commandBuffer, pBeginInfo); } -LOADER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer) +LOADER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCommandBuffer commandBuffer) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - return disp->EndCommandBuffer(cmdBuffer); + return disp->EndCommandBuffer(commandBuffer); } -LOADER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) +LOADER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - return disp->ResetCommandBuffer(cmdBuffer, flags); + return disp->ResetCommandBuffer(commandBuffer, flags); } -LOADER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +LOADER_EXPORT void VKAPI vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); + disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); } -LOADER_EXPORT void VKAPI vkCmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports) +LOADER_EXPORT void VKAPI vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdSetViewport(cmdBuffer, viewportCount, pViewports); + disp->CmdSetViewport(commandBuffer, viewportCount, pViewports); } -LOADER_EXPORT void VKAPI vkCmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +LOADER_EXPORT void VKAPI vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdSetScissor(cmdBuffer, scissorCount, pScissors); + disp->CmdSetScissor(commandBuffer, scissorCount, pScissors); } -LOADER_EXPORT void VKAPI vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth) +LOADER_EXPORT void VKAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdSetLineWidth(cmdBuffer, lineWidth); + disp->CmdSetLineWidth(commandBuffer, lineWidth); } -LOADER_EXPORT void VKAPI vkCmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +LOADER_EXPORT void VKAPI vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdSetDepthBias(cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); + disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); } -LOADER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConstants[4]) +LOADER_EXPORT void VKAPI vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdSetBlendConstants(cmdBuffer, blendConstants); + disp->CmdSetBlendConstants(commandBuffer, blendConstants); } -LOADER_EXPORT void VKAPI vkCmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) +LOADER_EXPORT void VKAPI vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds); + disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); } -LOADER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) +LOADER_EXPORT void VKAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask); + disp->CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask); } -LOADER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) +LOADER_EXPORT void VKAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask); + disp->CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask); } -LOADER_EXPORT void VKAPI vkCmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) +LOADER_EXPORT void VKAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdSetStencilReference(cmdBuffer, faceMask, stencilReference); + disp->CmdSetStencilReference(commandBuffer, faceMask, stencilReference); } -LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); } -LOADER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +LOADER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); + disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); } -LOADER_EXPORT void VKAPI vkCmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +LOADER_EXPORT void VKAPI vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets); + disp->CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets); } -LOADER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +LOADER_EXPORT void VKAPI vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdDraw(cmdBuffer, vertexCount, instanceCount, firstVertex, firstInstance); + disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); } -LOADER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +LOADER_EXPORT void VKAPI vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdDrawIndexed(cmdBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); } -LOADER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +LOADER_EXPORT void VKAPI vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdDrawIndirect(cmdBuffer, buffer, offset, drawCount, stride); + disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); } -LOADER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +LOADER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, drawCount, stride); + disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); } -LOADER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) +LOADER_EXPORT void VKAPI vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdDispatch(cmdBuffer, x, y, z); + disp->CmdDispatch(commandBuffer, x, y, z); } -LOADER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) +LOADER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdDispatchIndirect(cmdBuffer, buffer, offset); + disp->CmdDispatchIndirect(commandBuffer, buffer, offset); } -LOADER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +LOADER_EXPORT void VKAPI vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); + disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); } -LOADER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +LOADER_EXPORT void VKAPI vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); + disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } -LOADER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +LOADER_EXPORT void VKAPI vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter); + disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); } -LOADER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +LOADER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); + disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); } -LOADER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +LOADER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); + disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); } -LOADER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) +LOADER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData); + disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); } -LOADER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data) +LOADER_EXPORT void VKAPI vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data); + disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); } -LOADER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +LOADER_EXPORT void VKAPI vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges); + disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); } -LOADER_EXPORT void VKAPI vkCmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +LOADER_EXPORT void VKAPI vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); + disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); } -LOADER_EXPORT void VKAPI vkCmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +LOADER_EXPORT void VKAPI vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdClearAttachments(cmdBuffer, attachmentCount, pAttachments, rectCount, pRects); + disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); } -LOADER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +LOADER_EXPORT void VKAPI vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); + disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } -LOADER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) +LOADER_EXPORT void VKAPI vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdSetEvent(cmdBuffer, event, stageMask); + disp->CmdSetEvent(commandBuffer, event, stageMask); } -LOADER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) +LOADER_EXPORT void VKAPI vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdResetEvent(cmdBuffer, event, stageMask); + disp->CmdResetEvent(commandBuffer, event, stageMask); } -LOADER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) +LOADER_EXPORT void VKAPI vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers); + disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers); } -LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) +LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, dependencyFlags, memBarrierCount, ppMemBarriers); + disp->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers); } -LOADER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) +LOADER_EXPORT void VKAPI vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdBeginQuery(cmdBuffer, queryPool, slot, flags); + disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags); } -LOADER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) +LOADER_EXPORT void VKAPI vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdEndQuery(cmdBuffer, queryPool, slot); + disp->CmdEndQuery(commandBuffer, queryPool, slot); } -LOADER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) +LOADER_EXPORT void VKAPI vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); + disp->CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount); } -LOADER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) +LOADER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot); + disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot); } -LOADER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkFlags flags) +LOADER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkFlags flags) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, stride, flags); + disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, stride, flags); } -LOADER_EXPORT void VKAPI vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) +LOADER_EXPORT void VKAPI vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdPushConstants(cmdBuffer, layout, stageFlags, offset, size, values); + disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, values); } -LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) +LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents); + disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); } -LOADER_EXPORT void VKAPI vkCmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents) +LOADER_EXPORT void VKAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkRenderPassContents contents) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdNextSubpass(cmdBuffer, contents); + disp->CmdNextSubpass(commandBuffer, contents); } -LOADER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer) +LOADER_EXPORT void VKAPI vkCmdEndRenderPass(VkCommandBuffer commandBuffer) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdEndRenderPass(cmdBuffer); + disp->CmdEndRenderPass(commandBuffer); } -LOADER_EXPORT void VKAPI vkCmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) +LOADER_EXPORT void VKAPI vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers) { const VkLayerDispatchTable *disp; - disp = loader_get_dispatch(cmdBuffer); + disp = loader_get_dispatch(commandBuffer); - disp->CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers); + disp->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers); } diff --git a/loader/vk-loader-generate.py b/loader/vk-loader-generate.py index 6439703e..d8d06b44 100755 --- a/loader/vk-loader-generate.py +++ b/loader/vk-loader-generate.py @@ -49,7 +49,7 @@ class Subcommand(object): # Dont be cute trying to use a general rule to programmatically populate this list # it just obsfucates what is going on! wsi_creates_dispatchable_object = ["CreateSwapchainKHR"] - creates_dispatchable_object = ["CreateDevice", "GetDeviceQueue", "AllocCommandBuffers"] + wsi_creates_dispatchable_object + creates_dispatchable_object = ["CreateDevice", "GetDeviceQueue", "AllocateCommandBuffers"] + wsi_creates_dispatchable_object if name in creates_dispatchable_object: return True else: diff --git a/loader/wsi_swapchain.c b/loader/wsi_swapchain.c index a20549a8..e362139a 100644 --- a/loader/wsi_swapchain.c +++ b/loader/wsi_swapchain.c @@ -36,7 +36,7 @@ #include "wsi_swapchain.h" static const VkExtensionProperties wsi_swapchain_extension_info = { - .extName = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME, + .extensionName = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME, .specVersion = VK_EXT_KHR_SWAPCHAIN_REVISION, }; -- cgit v1.2.3