From 1573582e3bee0ed2c92af3d82a43fb49b1dde1fc Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Wed, 25 Nov 2015 10:30:56 -0700 Subject: layers: Rename DebugReport flags Conflicts: layers/mem_tracker.cpp Conflicts: layers/draw_state.cpp --- demos/cube.c | 6 +- demos/tri.c | 6 +- icd/common/icd-enumerate-drm.c | 4 +- include/vulkan/vk_lunarg_debug_report.h | 15 +- layers/device_limits.cpp | 36 +-- layers/draw_state.cpp | 330 ++++++++++++++-------------- layers/image.cpp | 120 +++++----- layers/mem_tracker.cpp | 114 +++++----- layers/object_track.h | 50 ++--- layers/param_checker.cpp | 374 ++++++++++++++++---------------- layers/swapchain.cpp | 4 +- layers/swapchain.h | 6 +- layers/vk_layer_config.cpp | 40 ++-- layers/vk_layer_logging.h | 6 +- loader/debug_report.c | 10 +- loader/loader.c | 134 ++++++------ vk-layer-generate.py | 30 +-- 17 files changed, 643 insertions(+), 642 deletions(-) diff --git a/demos/cube.c b/demos/cube.c index 25cf0773..83237072 100644 --- a/demos/cube.c +++ b/demos/cube.c @@ -269,9 +269,9 @@ VkBool32 dbgFunc( assert (message); - if (msgFlags & VK_DBG_REPORT_ERROR_BIT) { + if (msgFlags & VK_DEBUG_REPORT_ERROR_BIT) { sprintf(message,"ERROR: [%s] Code %d : %s", pLayerPrefix, msgCode, pMsg); - } else if (msgFlags & VK_DBG_REPORT_WARN_BIT) { + } else if (msgFlags & VK_DEBUG_REPORT_WARN_BIT) { // We know that we're submitting queues without fences, ignore this warning if (strstr(pMsg, "vkQueueSubmit parameter, VkFence fence, is null pointer")){ return false; @@ -2340,7 +2340,7 @@ static void demo_init_vk(struct demo *demo) } err = demo->dbgCreateMsgCallback( demo->inst, - VK_DBG_REPORT_ERROR_BIT | VK_DBG_REPORT_WARN_BIT, + VK_DEBUG_REPORT_ERROR_BIT | VK_DEBUG_REPORT_WARN_BIT, callback, NULL, &demo->msg_callback); switch (err) { diff --git a/demos/tri.c b/demos/tri.c index 17b53443..631eab96 100644 --- a/demos/tri.c +++ b/demos/tri.c @@ -121,9 +121,9 @@ VkBool32 dbgFunc( assert (message); - if (msgFlags & VK_DBG_REPORT_ERROR_BIT) { + if (msgFlags & VK_DEBUG_REPORT_ERROR_BIT) { sprintf(message,"ERROR: [%s] Code %d : %s", pLayerPrefix, msgCode, pMsg); - } else if (msgFlags & VK_DBG_REPORT_WARN_BIT) { + } else if (msgFlags & VK_DEBUG_REPORT_WARN_BIT) { sprintf(message,"WARNING: [%s] Code %d : %s", pLayerPrefix, msgCode, pMsg); } else { return false; @@ -1953,7 +1953,7 @@ static void demo_init_vk(struct demo *demo) } err = demo->dbgCreateMsgCallback( demo->inst, - VK_DBG_REPORT_ERROR_BIT | VK_DBG_REPORT_WARN_BIT, + VK_DEBUG_REPORT_ERROR_BIT | VK_DEBUG_REPORT_WARN_BIT, dbgFunc, NULL, &demo->msg_callback); switch (err) { diff --git a/icd/common/icd-enumerate-drm.c b/icd/common/icd-enumerate-drm.c index 3b5deb9f..7c3769ec 100644 --- a/icd/common/icd-enumerate-drm.c +++ b/icd/common/icd-enumerate-drm.c @@ -150,7 +150,7 @@ struct icd_drm_device *icd_drm_enumerate(const struct icd_instance *instance, udev = udev_new(); if (udev == NULL) { - icd_instance_log(instance, VK_DBG_REPORT_ERROR_BIT, + icd_instance_log(instance, VK_DEBUG_REPORT_ERROR_BIT, 0, VK_NULL_HANDLE, /* obj_type, object */ 0, 0, /* location, msg_code */ "failed to initialize udev context"); @@ -160,7 +160,7 @@ struct icd_drm_device *icd_drm_enumerate(const struct icd_instance *instance, e = udev_enumerate_new(udev); if (e == NULL) { - icd_instance_log(instance, VK_DBG_REPORT_ERROR_BIT, + icd_instance_log(instance, VK_DEBUG_REPORT_ERROR_BIT, 0, VK_NULL_HANDLE, /* obj_type, object */ 0, 0, /* location, msg_code */ "failed to initialize udev enumerate context"); diff --git a/include/vulkan/vk_lunarg_debug_report.h b/include/vulkan/vk_lunarg_debug_report.h index d92a1e1c..dfd27c55 100644 --- a/include/vulkan/vk_lunarg_debug_report.h +++ b/include/vulkan/vk_lunarg_debug_report.h @@ -89,14 +89,15 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDbgMsgCallback) // ------------------------------------------------------------------------------------------------ // Enumerations -typedef enum VkDbgReportFlags_ +typedef enum VkDebugReportFlagsLUNARG_ { - VK_DBG_REPORT_INFO_BIT = 0x0001, - VK_DBG_REPORT_WARN_BIT = 0x0002, - VK_DBG_REPORT_PERF_WARN_BIT = 0x0004, - VK_DBG_REPORT_ERROR_BIT = 0x0008, - VK_DBG_REPORT_DEBUG_BIT = 0x0010, -} VkDbgReportFlags; + VK_DEBUG_REPORT_INFO_BIT = 0x0001, + VK_DEBUG_REPORT_WARN_BIT = 0x0002, + VK_DEBUG_REPORT_PERF_WARN_BIT = 0x0004, + VK_DEBUG_REPORT_ERROR_BIT = 0x0008, + VK_DEBUG_REPORT_DEBUG_BIT = 0x0010, +} VkDebugReportFlagBitsLUNARG; +typedef VkFlags VkDebugReportFlagsLUNARG; // Debug Report ERROR codes typedef enum _DEBUG_REPORT_ERROR diff --git a/layers/device_limits.cpp b/layers/device_limits.cpp index 7dbca10f..9de4a12e 100644 --- a/layers/device_limits.cpp +++ b/layers/device_limits.cpp @@ -216,11 +216,11 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInst } else { if (UNCALLED == my_data->instanceState->vkEnumeratePhysicalDevicesState) { // Flag error here, shouldn't be calling this without having queried count - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_INSTANCE, 0, 0, DEVLIMITS_MUST_QUERY_COUNT, "DL", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_INSTANCE, 0, 0, DEVLIMITS_MUST_QUERY_COUNT, "DL", "Invalid call sequence to vkEnumeratePhysicalDevices() w/ non-NULL pPhysicalDevices. You should first call vkEnumeratePhysicalDevices() w/ NULL pPhysicalDevices to query pPhysicalDeviceCount."); } // TODO : Could also flag a warning if re-calling this function in QUERY_DETAILS state else if (my_data->instanceState->physicalDevicesCount != *pPhysicalDeviceCount) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_COUNT_MISMATCH, "DL", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_COUNT_MISMATCH, "DL", "Call to vkEnumeratePhysicalDevices() w/ pPhysicalDeviceCount value %u, but actual count supported by this instance is %u.", *pPhysicalDeviceCount, my_data->instanceState->physicalDevicesCount); } my_data->instanceState->vkEnumeratePhysicalDevicesState = QUERY_DETAILS; @@ -241,7 +241,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInst } return result; } else { - log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_INSTANCE, 0, 0, DEVLIMITS_INVALID_INSTANCE, "DL", + log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_INSTANCE, 0, 0, DEVLIMITS_INVALID_INSTANCE, "DL", "Invalid instance (%#" PRIxLEAST64 ") passed into vkEnumeratePhysicalDevices().", (uint64_t)instance); } return VK_ERROR_VALIDATION_FAILED; @@ -281,12 +281,12 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPropert } else { // Verify that for each physical device, this function is called first with NULL pQueueFamilyProperties ptr in order to get count if (UNCALLED == phy_dev_data->physicalDeviceState->vkGetPhysicalDeviceQueueFamilyPropertiesState) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_MUST_QUERY_COUNT, "DL", + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_MUST_QUERY_COUNT, "DL", "Invalid call sequence to vkGetPhysicalDeviceQueueFamilyProperties() w/ non-NULL pQueueFamilyProperties. You should first call vkGetPhysicalDeviceQueueFamilyProperties() w/ NULL pQueueFamilyProperties to query pCount."); } // Then verify that pCount that is passed in on second call matches what was returned if (phy_dev_data->physicalDeviceState->queueFamilyPropertiesCount != *pCount) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_COUNT_MISMATCH, "DL", + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_COUNT_MISMATCH, "DL", "Call to vkGetPhysicalDeviceQueueFamilyProperties() w/ pCount value %u, but actual count supported by this physicalDevice is %u.", *pCount, phy_dev_data->physicalDeviceState->queueFamilyPropertiesCount); } phy_dev_data->physicalDeviceState->vkGetPhysicalDeviceQueueFamilyPropertiesState = QUERY_DETAILS; @@ -304,7 +304,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPropert } return; } else { - log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_PHYSICAL_DEVICE, "DL", + log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_PHYSICAL_DEVICE, "DL", "Invalid physicalDevice (%#" PRIxLEAST64 ") passed into vkGetPhysicalDeviceQueueFamilyProperties().", (uint64_t)physicalDevice); } } @@ -377,14 +377,14 @@ static VkBool32 validate_features_request(layer_data *phy_dev_data) uint32_t totalBools = sizeof(VkPhysicalDeviceFeatures)/sizeof(VkBool32); for (uint32_t i = 0; i < totalBools; i++) { if (requested[i] > actual[i]) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_FEATURE_REQUESTED, "DL", + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_FEATURE_REQUESTED, "DL", "While calling vkCreateDevice(), requesting feature #%u in VkPhysicalDeviceFeatures struct, which is not available on this device.", i); errors++; } } if (errors && (UNCALLED == phy_dev_data->physicalDeviceState->vkGetPhysicalDeviceFeaturesState)) { // If user didn't request features, notify them that they should - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_FEATURE_REQUESTED, "DL", + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_FEATURE_REQUESTED, "DL", "You requested features that are unavailable on this device. You should first query feature availability by calling vkGetPhysicalDeviceFeatures()."); } return skipCall; @@ -396,20 +396,20 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice g layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map); // First check is app has actually requested queueFamilyProperties if (!phy_dev_data->physicalDeviceState) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_MUST_QUERY_COUNT, "DL", + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_MUST_QUERY_COUNT, "DL", "Invalid call to vkCreateDevice() w/o first calling vkEnumeratePhysicalDevices()."); } else if (QUERY_DETAILS != phy_dev_data->physicalDeviceState->vkGetPhysicalDeviceQueueFamilyPropertiesState) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL", + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL", "Invalid call to vkCreateDevice() w/o first calling vkGetPhysicalDeviceQueueFamilyProperties()."); } else { // Check that the requested queue properties are valid for (uint32_t i=0; iqueueCreateInfoCount; i++) { uint32_t requestedIndex = pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex; if (phy_dev_data->queueFamilyProperties.size() <= requestedIndex) { // requested index is out of bounds for this physical device - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL", + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL", "Invalid queue create request in vkCreateDevice(). Invalid queueFamilyIndex %u requested.", requestedIndex); } else if (pCreateInfo->pQueueCreateInfos[i].queueCount > phy_dev_data->queueFamilyProperties[requestedIndex]->queueCount) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL", + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL", "Invalid queue create request in vkCreateDevice(). QueueFamilyIndex %u only has %u queues, but requested queueCount is %u.", requestedIndex, phy_dev_data->queueFamilyProperties[requestedIndex]->queueCount, pCreateInfo->pQueueCreateInfos[i].queueCount); } } @@ -479,10 +479,10 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uin VkPhysicalDevice gpu = dev_data->physicalDevice; layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map); if (queueFamilyIndex >= phy_dev_data->queueFamilyProperties.size()) { // requested index is out of bounds for this physical device - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL", + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL", "Invalid queueFamilyIndex %u requested in vkGetDeviceQueue().", queueFamilyIndex); } else if (queueIndex >= phy_dev_data->queueFamilyProperties[queueFamilyIndex]->queueCount) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL", + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL", "Invalid queue request in vkGetDeviceQueue(). QueueFamilyIndex %u only has %u queues, but requested queueIndex is %u.", queueFamilyIndex, phy_dev_data->queueFamilyProperties[queueFamilyIndex]->queueCount, queueIndex); } if (skipCall) @@ -502,7 +502,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( // dstOffset is the byte offset into the buffer to start updating and must be a multiple of 4. if (dstOffset & 3) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL", "vkCmdUpdateBuffer parameter, VkDeviceSize dstOffset, is not a multiple of 4")) { return; } @@ -511,7 +511,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( // dataSize is the number of bytes to update, which must be a multiple of 4. if (dataSize & 3) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL", "vkCmdUpdateBuffer parameter, VkDeviceSize dataSize, is not a multiple of 4")) { return; } @@ -532,7 +532,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( // dstOffset is the byte offset into the buffer to start filling and must be a multiple of 4. if (dstOffset & 3) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL", "vkCmdFillBuffer parameter, VkDeviceSize dstOffset, is not a multiple of 4")) { return; } @@ -541,7 +541,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( // size is the number of bytes to fill, which must be a multiple of 4. if (size & 3) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "DL", "vkCmdFillBuffer parameter, VkDeviceSize size, is not a multiple of 4")) { return; } diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index 5953de48..4b5daa84 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -582,7 +582,7 @@ collect_interface_by_location(layer_data *my_data, VkDevice dev, * The spec says nothing about how this case works (or doesn't) * for interface matching. */ - log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INCONSISTENT_SPIRV, "SC", + log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INCONSISTENT_SPIRV, "SC", "var %d (type %d) in %s interface has no Location or Builtin decoration", code[word+2], code[word+1], storage_class_name(sinterface)); } @@ -654,7 +654,7 @@ collect_interface_by_descriptor_slot(layer_data *my_data, VkDevice dev, auto existing_it = out.find(std::make_pair(set, binding)); if (existing_it != out.end()) { /* conflict within spv image */ - log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, + log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INCONSISTENT_SPIRV, "SC", "var %d (type %d) in %s interface in descriptor slot (%u,%u) conflicts with existing definition", code[word+2], code[word+1], storage_class_name(sinterface), @@ -700,14 +700,14 @@ validate_interface_between_stages(layer_data *my_data, VkDevice dev, auto b_first = b_at_end ? 0 : b_it->first; if (b_at_end || ((!a_at_end) && (a_first < b_first))) { - if (log_msg(my_data->report_data, VK_DBG_REPORT_PERF_WARN_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_PERF_WARN_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC", "%s writes to output location %d which is not consumed by %s", producer_name, a_first, consumer_name)) { pass = false; } a_it++; } else if (a_at_end || a_first > b_first) { - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC", "%s consumes input location %d which is not written by %s", consumer_name, b_first, producer_name)) { pass = false; } @@ -723,7 +723,7 @@ validate_interface_between_stages(layer_data *my_data, VkDevice dev, describe_type(producer_type, producer, a_it->second.type_id); describe_type(consumer_type, consumer, b_it->second.type_id); - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC", "Type mismatch on location %d: '%s' vs '%s'", a_it->first, producer_type, consumer_type)) { pass = false; } @@ -831,7 +831,7 @@ validate_vi_consistency(layer_data *my_data, VkDevice dev, VkPipelineVertexInput auto desc = &vi->pVertexBindingDescriptions[i]; auto & binding = bindings[desc->binding]; if (binding) { - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INCONSISTENT_VI, "SC", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INCONSISTENT_VI, "SC", "Duplicate vertex input binding descriptions for binding %d", desc->binding)) { pass = false; } @@ -872,14 +872,14 @@ validate_vi_against_vs_inputs(layer_data *my_data, VkDevice dev, VkPipelineVerte auto a_first = a_at_end ? 0 : it_a->first; auto b_first = b_at_end ? 0 : it_b->first; if (b_at_end || a_first < b_first) { - if (log_msg(my_data->report_data, VK_DBG_REPORT_PERF_WARN_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_PERF_WARN_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC", "Vertex attribute at location %d not consumed by VS", a_first)) { pass = false; } it_a++; } else if (a_at_end || b_first < a_first) { - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC", "VS consumes input at location %d but not provided", b_first)) { pass = false; } @@ -893,7 +893,7 @@ validate_vi_against_vs_inputs(layer_data *my_data, VkDevice dev, VkPipelineVerte if (attrib_type != FORMAT_TYPE_UNDEFINED && input_type != FORMAT_TYPE_UNDEFINED && attrib_type != input_type) { char vs_type[1024]; describe_type(vs_type, vs, it_b->second.type_id); - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC", "Attribute type of `%s` at location %d does not match VS input type of `%s`", string_VkFormat(it_a->second->format), a_first, vs_type)) { pass = false; @@ -931,14 +931,14 @@ validate_fs_outputs_against_render_pass(layer_data *my_data, VkDevice dev, shade /* TODO: Figure out compile error with cb->attachmentCount */ while ((outputs.size() > 0 && it != outputs.end()) || attachment < color_formats.size()) { if (attachment == color_formats.size() || ( it != outputs.end() && it->first < attachment)) { - if (log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_OUTPUT_NOT_CONSUMED, "SC", "FS writes to output location %d with no matching attachment", it->first)) { pass = false; } it++; } else if (it == outputs.end() || it->first > attachment) { - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INPUT_NOT_PRODUCED, "SC", "Attachment %d not written by FS", attachment)) { pass = false; } @@ -952,7 +952,7 @@ validate_fs_outputs_against_render_pass(layer_data *my_data, VkDevice dev, shade if (att_type != FORMAT_TYPE_UNDEFINED && output_type != FORMAT_TYPE_UNDEFINED && att_type != output_type) { char fs_type[1024]; describe_type(fs_type, fs, it->second.type_id); - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_INTERFACE_TYPE_MISMATCH, "SC", "Attachment %d of type `%s` does not match FS output type of `%s`", attachment, string_VkFormat(color_formats[attachment]), fs_type)) { pass = false; @@ -1074,17 +1074,17 @@ static VkBool32 isDynamic(const PIPELINE_NODE* pPipeline, const VkDynamicState s // Validate state stored as flags at time of draw call static VkBool32 validate_draw_state_flags(layer_data* my_data, GLOBAL_CB_NODE* pCB, VkBool32 indexedDraw) { VkBool32 result; - result = validate_status(my_data, pCB, CBSTATUS_NONE, CBSTATUS_VIEWPORT_SET, CBSTATUS_VIEWPORT_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_VIEWPORT_NOT_BOUND, "Dynamic viewport state not set for this command buffer"); - result |= validate_status(my_data, pCB, CBSTATUS_NONE, CBSTATUS_SCISSOR_SET, CBSTATUS_SCISSOR_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_SCISSOR_NOT_BOUND, "Dynamic scissor state not set for this command buffer"); - result |= validate_status(my_data, pCB, CBSTATUS_NONE, CBSTATUS_LINE_WIDTH_SET, CBSTATUS_LINE_WIDTH_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_LINE_WIDTH_NOT_BOUND, "Dynamic line width state not set for this command buffer"); - result |= validate_status(my_data, pCB, CBSTATUS_NONE, CBSTATUS_DEPTH_BIAS_SET, CBSTATUS_DEPTH_BIAS_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_BIAS_NOT_BOUND, "Dynamic depth bias state not set for this command buffer"); - result |= validate_status(my_data, pCB, CBSTATUS_COLOR_BLEND_WRITE_ENABLE, CBSTATUS_BLEND_SET, CBSTATUS_BLEND_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_BLEND_NOT_BOUND, "Dynamic blend object state not set for this command buffer"); - result |= validate_status(my_data, pCB, CBSTATUS_DEPTH_WRITE_ENABLE, CBSTATUS_DEPTH_BOUNDS_SET, CBSTATUS_DEPTH_BOUNDS_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_BOUNDS_NOT_BOUND, "Dynamic depth bounds state not set for this command buffer"); - result |= validate_status(my_data, pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_READ_MASK_SET, CBSTATUS_STENCIL_READ_MASK_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Dynamic stencil read mask state not set for this command buffer"); - result |= validate_status(my_data, pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_WRITE_MASK_SET, CBSTATUS_STENCIL_WRITE_MASK_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Dynamic stencil write mask state not set for this command buffer"); - result |= validate_status(my_data, pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_REFERENCE_SET, CBSTATUS_STENCIL_REFERENCE_SET, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Dynamic stencil reference state not set for this command buffer"); + result = validate_status(my_data, pCB, CBSTATUS_NONE, CBSTATUS_VIEWPORT_SET, CBSTATUS_VIEWPORT_SET, VK_DEBUG_REPORT_ERROR_BIT, DRAWSTATE_VIEWPORT_NOT_BOUND, "Dynamic viewport state not set for this command buffer"); + result |= validate_status(my_data, pCB, CBSTATUS_NONE, CBSTATUS_SCISSOR_SET, CBSTATUS_SCISSOR_SET, VK_DEBUG_REPORT_ERROR_BIT, DRAWSTATE_SCISSOR_NOT_BOUND, "Dynamic scissor state not set for this command buffer"); + result |= validate_status(my_data, pCB, CBSTATUS_NONE, CBSTATUS_LINE_WIDTH_SET, CBSTATUS_LINE_WIDTH_SET, VK_DEBUG_REPORT_ERROR_BIT, DRAWSTATE_LINE_WIDTH_NOT_BOUND, "Dynamic line width state not set for this command buffer"); + result |= validate_status(my_data, pCB, CBSTATUS_NONE, CBSTATUS_DEPTH_BIAS_SET, CBSTATUS_DEPTH_BIAS_SET, VK_DEBUG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_BIAS_NOT_BOUND, "Dynamic depth bias state not set for this command buffer"); + result |= validate_status(my_data, pCB, CBSTATUS_COLOR_BLEND_WRITE_ENABLE, CBSTATUS_BLEND_SET, CBSTATUS_BLEND_SET, VK_DEBUG_REPORT_ERROR_BIT, DRAWSTATE_BLEND_NOT_BOUND, "Dynamic blend object state not set for this command buffer"); + result |= validate_status(my_data, pCB, CBSTATUS_DEPTH_WRITE_ENABLE, CBSTATUS_DEPTH_BOUNDS_SET, CBSTATUS_DEPTH_BOUNDS_SET, VK_DEBUG_REPORT_ERROR_BIT, DRAWSTATE_DEPTH_BOUNDS_NOT_BOUND, "Dynamic depth bounds state not set for this command buffer"); + result |= validate_status(my_data, pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_READ_MASK_SET, CBSTATUS_STENCIL_READ_MASK_SET, VK_DEBUG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Dynamic stencil read mask state not set for this command buffer"); + result |= validate_status(my_data, pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_WRITE_MASK_SET, CBSTATUS_STENCIL_WRITE_MASK_SET, VK_DEBUG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Dynamic stencil write mask state not set for this command buffer"); + result |= validate_status(my_data, pCB, CBSTATUS_STENCIL_TEST_ENABLE, CBSTATUS_STENCIL_REFERENCE_SET, CBSTATUS_STENCIL_REFERENCE_SET, VK_DEBUG_REPORT_ERROR_BIT, DRAWSTATE_STENCIL_NOT_BOUND, "Dynamic stencil reference state not set for this command buffer"); if (indexedDraw) - result |= validate_status(my_data, pCB, CBSTATUS_NONE, CBSTATUS_INDEX_BUFFER_BOUND, CBSTATUS_INDEX_BUFFER_BOUND, VK_DBG_REPORT_ERROR_BIT, DRAWSTATE_INDEX_BUFFER_NOT_BOUND, "Index buffer object not bound to this command buffer when Indexed Draw attempted"); + result |= validate_status(my_data, pCB, CBSTATUS_NONE, CBSTATUS_INDEX_BUFFER_BOUND, CBSTATUS_INDEX_BUFFER_BOUND, VK_DEBUG_REPORT_ERROR_BIT, DRAWSTATE_INDEX_BUFFER_NOT_BOUND, "Index buffer object not bound to this command buffer when Indexed Draw attempted"); return result; } @@ -1157,7 +1157,7 @@ validate_pipeline_shaders(layer_data *my_data, VkDevice dev, PIPELINE_NODE* pPip if ((pStage->stage & (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)) == 0) { - if (log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_UNKNOWN_STAGE, "SC", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_UNKNOWN_STAGE, "SC", "Unknown shader stage %d", pStage->stage)) { pass = false; } @@ -1184,7 +1184,7 @@ validate_pipeline_shaders(layer_data *my_data, VkDevice dev, PIPELINE_NODE* pPip if (!found) { char type_name[1024]; describe_type(type_name, module, it->second.type_id); - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_MISSING_DESCRIPTOR, "SC", "Shader uses descriptor slot %u.%u (used as type `%s`) but not declared in pipeline layout", it->first.first, it->first.second, type_name)) { @@ -1253,12 +1253,12 @@ static VkBool32 validate_draw_state(layer_data* my_data, GLOBAL_CB_NODE* pCB, Vk for (auto setIndex : pPipe->active_sets) { // If valid set is not bound throw an error if ((pCB->boundDescriptorSets.size() <= setIndex) || (!pCB->boundDescriptorSets[setIndex])) { - result |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_DESCRIPTOR_SET_NOT_BOUND, "DS", + result |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_DESCRIPTOR_SET_NOT_BOUND, "DS", "VkPipeline %#" PRIxLEAST64 " uses set #%u but that set is not bound.", (uint64_t)pPipe->pipeline, setIndex); } else if (!verify_set_layout_compatibility(my_data, my_data->setMap[pCB->boundDescriptorSets[setIndex]], pPipe->graphicsPipelineCI.layout, setIndex, errorString)) { // Set is bound but not compatible w/ overlapping pipelineLayout from PSO VkDescriptorSet setHandle = my_data->setMap[pCB->boundDescriptorSets[setIndex]]->set; - result |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t)setHandle, 0, DRAWSTATE_PIPELINE_LAYOUTS_INCOMPATIBLE, "DS", + result |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t)setHandle, 0, DRAWSTATE_PIPELINE_LAYOUTS_INCOMPATIBLE, "DS", "VkDescriptorSet (%#" PRIxLEAST64 ") bound as set #%u is not compatible with overlapping VkPipelineLayout %#" PRIxLEAST64 " due to: %s", (uint64_t)setHandle, setIndex, (uint64_t)pPipe->graphicsPipelineCI.layout, errorString.c_str()); } } @@ -1267,11 +1267,11 @@ static VkBool32 validate_draw_state(layer_data* my_data, GLOBAL_CB_NODE* pCB, Vk if (MAX_BINDING != pCB->lastVtxBinding) { if (pCB->lastVtxBinding >= pPipe->vtxBindingCount) { if (0 == pPipe->vtxBindingCount) { - result |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", + result |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", "Vtx Buffer Index %u was bound, but no vtx buffers are attached to PSO.", pCB->lastVtxBinding); } else { - result |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", + result |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VTX_INDEX_OUT_OF_BOUNDS, "DS", "Vtx binding Index of %u exceeds PSO pVertexBindingDescriptions max array index of %u.", pCB->lastVtxBinding, (pPipe->vtxBindingCount - 1)); } } @@ -1281,14 +1281,14 @@ static VkBool32 validate_draw_state(layer_data* my_data, GLOBAL_CB_NODE* pCB, Vk VkBool32 dynScissor = isDynamic(pPipe, VK_DYNAMIC_STATE_SCISSOR); if (dynViewport) { if (pCB->viewports.size() != pPipe->graphicsPipelineCI.pViewportState->viewportCount) { - result |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", + result |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", "Dynamic viewportCount from vkCmdSetViewport() is " PRINTF_SIZE_T_SPECIFIER ", but PSO viewportCount is %u. These counts must match.", pCB->viewports.size(), pPipe->graphicsPipelineCI.pViewportState->viewportCount); } } if (dynScissor) { if (pCB->scissors.size() != pPipe->graphicsPipelineCI.pViewportState->scissorCount) { - result |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", + result |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", "Dynamic scissorCount from vkCmdSetScissor() is " PRINTF_SIZE_T_SPECIFIER ", but PSO scissorCount is %u. These counts must match.", pCB->scissors.size(), pPipe->graphicsPipelineCI.pViewportState->scissorCount); } @@ -1306,13 +1306,13 @@ static VkBool32 verifyPipelineCreateState(layer_data* my_data, const VkDevice de } // VS is required if (!(pPipeline->active_shaders & VK_SHADER_STAGE_VERTEX_BIT)) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: Vtx Shader required"); } // Either both or neither TC/TE shaders should be defined if (((pPipeline->active_shaders & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) == 0) != ((pPipeline->active_shaders & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) == 0) ) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: TE and TC shaders must be included or excluded as a pair"); } // Compute shaders should be specified independent of Gfx shaders @@ -1320,23 +1320,23 @@ static VkBool32 verifyPipelineCreateState(layer_data* my_data, const VkDevice de (pPipeline->active_shaders & (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT | VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_FRAGMENT_BIT))) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: Do not specify Compute Shader for Gfx Pipeline"); } // VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive topology is only valid for tessellation pipelines. // Mismatching primitive topology and tessellation fails graphics pipeline creation. if (pPipeline->active_shaders & (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) && (pPipeline->iaStateCI.topology != VK_PRIMITIVE_TOPOLOGY_PATCH_LIST)) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH_LIST must be set as IA topology for tessellation pipelines"); } if (pPipeline->iaStateCI.topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST) { if (~pPipeline->active_shaders & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive topology is only valid for tessellation pipelines"); } if (!pPipeline->tessStateCI.patchControlPoints || (pPipeline->tessStateCI.patchControlPoints > 32)) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive topology used with patchControlPoints value %u." " patchControlPoints should be >0 and <=32.", pPipeline->tessStateCI.patchControlPoints); } @@ -1344,10 +1344,10 @@ static VkBool32 verifyPipelineCreateState(layer_data* my_data, const VkDevice de // Viewport state must be included and viewport and scissor counts should always match // NOTE : Even if these are flagged as dynamic, counts need to be set correctly for shader compiler if (!pPipeline->graphicsPipelineCI.pViewportState) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", "Gfx Pipeline pViewportState is null. Even if viewport and scissors are dynamic PSO must include viewportCount and scissorCount in pViewportState."); } else if (pPipeline->graphicsPipelineCI.pViewportState->scissorCount != pPipeline->graphicsPipelineCI.pViewportState->viewportCount) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", "Gfx Pipeline viewport count (%u) must match scissor count (%u).", pPipeline->vpStateCI.viewportCount, pPipeline->vpStateCI.scissorCount); } else { // If viewport or scissor are not dynamic, then verify that data is appropriate for count @@ -1355,14 +1355,14 @@ static VkBool32 verifyPipelineCreateState(layer_data* my_data, const VkDevice de VkBool32 dynScissor = isDynamic(pPipeline, VK_DYNAMIC_STATE_SCISSOR); if (!dynViewport) { if (pPipeline->graphicsPipelineCI.pViewportState->viewportCount && !pPipeline->graphicsPipelineCI.pViewportState->pViewports) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", "Gfx Pipeline viewportCount is %u, but pViewports is NULL. For non-zero viewportCount, you must either include pViewports data, or " "include viewport in pDynamicState and set it with vkCmdSetViewport().", pPipeline->graphicsPipelineCI.pViewportState->viewportCount); } } if (!dynScissor) { if (pPipeline->graphicsPipelineCI.pViewportState->scissorCount && !pPipeline->graphicsPipelineCI.pViewportState->pScissors) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", "Gfx Pipeline scissorCount is %u, but pScissors is NULL. For non-zero scissorCount, you must either include pScissors data, or include " "scissor in pDynamicState and set it with vkCmdSetScissor().", pPipeline->graphicsPipelineCI.pViewportState->scissorCount); } @@ -1566,7 +1566,7 @@ static VkBool32 validatePipelineState(layer_data* my_data, const GLOBAL_CB_NODE* } if (psoNumSamples != subpassNumSamples) { - return log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS", + return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS", "Num samples mismatch! Binding PSO (%#" PRIxLEAST64 ") with %u samples while current RenderPass (%#" PRIxLEAST64 ") w/ %u samples!", (uint64_t) pipeline, psoNumSamples, (uint64_t) pCB->activeRenderPass, subpassNumSamples); } @@ -1626,7 +1626,7 @@ static VkBool32 validUpdateStruct(layer_data* my_data, const VkDevice device, co case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: return VK_FALSE; default: - return log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", + return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType); } } @@ -1699,7 +1699,7 @@ static VkBool32 validateUpdateConsistency(layer_data* my_data, const VkDevice de return VK_FALSE; break; default: - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType); } if (VK_FALSE == skipCall) { @@ -1707,12 +1707,12 @@ static VkBool32 validateUpdateConsistency(layer_data* my_data, const VkDevice de VkShaderStageFlags refStageFlags = pLayout->stageFlags[startIndex]; for (i = startIndex; i <= endIndex; i++) { if (pLayout->descriptorTypes[i] != actualType) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", "Write descriptor update has descriptor type %s that does not match overlapping binding descriptor type of %s!", string_VkDescriptorType(actualType), string_VkDescriptorType(pLayout->descriptorTypes[i])); } if (pLayout->stageFlags[i] != refStageFlags) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_DESCRIPTOR_STAGEFLAGS_MISMATCH, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_DESCRIPTOR_STAGEFLAGS_MISMATCH, "DS", "Write descriptor update has stageFlags %x that do not match overlapping binding descriptor stageFlags of %x!", refStageFlags, pLayout->stageFlags[i]); } @@ -1780,7 +1780,7 @@ static VkBool32 shadowUpdateNode(layer_data* my_data, const VkDevice device, GEN memcpy(pCDS, pUpdate, sizeof(VkCopyDescriptorSet)); break; default: - if (log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", + if (log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", string_VkStructureType(pUpdate->sType), pUpdate->sType)) return VK_TRUE; } @@ -1796,10 +1796,10 @@ static VkBool32 validateSampler(const layer_data* my_data, const VkSampler* pSam auto sampIt = my_data->sampleMap.find(*pSampler); if (sampIt == my_data->sampleMap.end()) { if (!immutable) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Attempt to update descriptor with invalid sampler %#" PRIxLEAST64, (uint64_t) *pSampler); } else { // immutable - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Attempt to update descriptor whose binding has an invalid immutable sampler %#" PRIxLEAST64, (uint64_t) *pSampler); } } else { @@ -1814,7 +1814,7 @@ static VkBool32 validateImageView(const layer_data* my_data, const VkImageView* VkBool32 skipCall = VK_FALSE; auto ivIt = my_data->imageViewMap.find(*pImageView); if (ivIt == my_data->imageViewMap.end()) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Attempt to update descriptor with invalid imageView %#" PRIxLEAST64, (uint64_t) *pImageView); } else { // Validate that imageLayout is compatible with aspectMask and image format @@ -1823,7 +1823,7 @@ static VkBool32 validateImageView(const layer_data* my_data, const VkImageView* // TODO : Check here in case we have a bad image auto imgIt = my_data->imageMap.find(image); if (imgIt == my_data->imageMap.end()) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t) image, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t) image, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Attempt to update descriptor with invalid image %#" PRIxLEAST64 " in imageView %#" PRIxLEAST64, (uint64_t) image, (uint64_t) *pImageView); } else { VkFormat format = (*imgIt).second->format; @@ -1832,13 +1832,13 @@ static VkBool32 validateImageView(const layer_data* my_data, const VkImageView* case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: // Only Color bit must be set if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, DRAWSTATE_INVALID_IMAGE_ASPECT, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL and imageView %#" PRIxLEAST64 "" " that does not have VK_IMAGE_ASPECT_COLOR_BIT set.", (uint64_t) *pImageView); } // format must NOT be DS if (ds) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL and imageView %#" PRIxLEAST64 "" " but the image format is %s which is not a color format.", (uint64_t) *pImageView, string_VkFormat(format)); } @@ -1849,19 +1849,19 @@ static VkBool32 validateImageView(const layer_data* my_data, const VkImageView* if (aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) { if (aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) { // both must NOT be set - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, DRAWSTATE_INVALID_IMAGE_ASPECT, "DS", "vkUpdateDescriptorSets: Updating descriptor with imageView %#" PRIxLEAST64 "" " that has both STENCIL and DEPTH aspects set", (uint64_t) *pImageView); } } else if (!(aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT)) { // Neither were set - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, DRAWSTATE_INVALID_IMAGE_ASPECT, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout %s and imageView %#" PRIxLEAST64 "" " that does not have STENCIL or DEPTH aspect set.", string_VkImageLayout(imageLayout), (uint64_t) *pImageView); } // format must be DS if (!ds) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout %s and imageView %#" PRIxLEAST64 "" " but the image format is %s which is not a depth/stencil format.", string_VkImageLayout(imageLayout), (uint64_t) *pImageView, string_VkFormat(format)); } @@ -1881,7 +1881,7 @@ static VkBool32 validateBufferView(const layer_data* my_data, const VkBufferView VkBool32 skipCall = VK_FALSE; auto sampIt = my_data->bufferViewMap.find(*pBufferView); if (sampIt == my_data->bufferViewMap.end()) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER_VIEW, (uint64_t) *pBufferView, 0, DRAWSTATE_BUFFERVIEW_DESCRIPTOR_ERROR, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER_VIEW, (uint64_t) *pBufferView, 0, DRAWSTATE_BUFFERVIEW_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Attempt to update descriptor with invalid bufferView %#" PRIxLEAST64, (uint64_t) *pBufferView); } else { // TODO : Any further checks we want to do on the bufferView? @@ -1895,7 +1895,7 @@ static VkBool32 validateBufferInfo(const layer_data* my_data, const VkDescriptor VkBool32 skipCall = VK_FALSE; auto sampIt = my_data->bufferMap.find(pBufferInfo->buffer); if (sampIt == my_data->bufferMap.end()) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER, (uint64_t) pBufferInfo->buffer, 0, DRAWSTATE_BUFFERINFO_DESCRIPTOR_ERROR, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER, (uint64_t) pBufferInfo->buffer, 0, DRAWSTATE_BUFFERINFO_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Attempt to update descriptor where bufferInfo has invalid buffer %#" PRIxLEAST64, (uint64_t) pBufferInfo->buffer); } else { // TODO : Any further checks we want to do on the bufferView? @@ -1926,14 +1926,14 @@ static VkBool32 validateUpdateContents(const layer_data* my_data, const VkWriteD if (NULL == pLayoutBinding->pImmutableSamplers) { pSampler = &(pWDS->pImageInfo[i].sampler); if (immutable) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS", "vkUpdateDescriptorSets: Update #%u is not an immutable sampler %#" PRIxLEAST64 ", but previous update(s) from this " "VkWriteDescriptorSet struct used an immutable sampler. All updates from a single struct must either " "use immutable or non-immutable samplers.", i, (uint64_t) *pSampler); } } else { if (i>0 && !immutable) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS", "vkUpdateDescriptorSets: Update #%u is an immutable sampler, but previous update(s) from this " "VkWriteDescriptorSet struct used a non-immutable sampler. All updates from a single struct must either " "use immutable or non-immutable samplers.", i); @@ -1992,7 +1992,7 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t descript binding = pWDS[i].dstBinding; // Make sure that layout being updated has the binding being updated if (pLayout->bindings.find(binding) == pLayout->bindings.end()) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", "Descriptor Set %" PRIu64 " does not have binding to match update binding %u for update type %s!", reinterpret_cast(ds), binding, string_VkStructureType(pUpdate->sType)); } else { // Next verify that update falls within size of given binding @@ -2000,7 +2000,7 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t descript if (getBindingEndIndex(pLayout, binding) < endIndex) { pLayoutCI = &pLayout->createInfo; string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} "); - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VkStructureType(pUpdate->sType), binding, DSstr.c_str()); } else { // TODO : should we skip update on a type mismatch or force it? uint32_t startIndex; @@ -2014,7 +2014,7 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t descript GENERIC_HEADER* pNewNode = NULL; skipCall |= shadowUpdateNode(my_data, device, pUpdate, &pNewNode); if (NULL == pNewNode) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", "Out of memory while attempting to allocate UPDATE struct in vkUpdateDescriptors()"); } else { // Insert shadow node into LL of updates for this set @@ -2043,11 +2043,11 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t descript pDstLayout = pDstSet->pLayout; // Validate that src binding is valid for src set layout if (pSrcLayout->bindings.find(pCDS[i].srcBinding) == pSrcLayout->bindings.end()) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", "Copy descriptor update %u has srcBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.", i, pCDS[i].srcBinding, (uint64_t) pSrcLayout->layout, pSrcLayout->createInfo.bindingCount-1); } else if (pDstLayout->bindings.find(pCDS[i].dstBinding) == pDstLayout->bindings.end()) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", "Copy descriptor update %u has dstBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.", i, pCDS[i].dstBinding, (uint64_t) pDstLayout->layout, pDstLayout->createInfo.bindingCount-1); } else { @@ -2057,12 +2057,12 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t descript if (getBindingEndIndex(pSrcLayout, pCDS[i].srcBinding) < srcEndIndex) { pLayoutCI = &pSrcLayout->createInfo; string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} "); - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", "Copy descriptor src update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].srcBinding, DSstr.c_str()); } else if (getBindingEndIndex(pDstLayout, pCDS[i].dstBinding) < dstEndIndex) { pLayoutCI = &pDstLayout->createInfo; string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} "); - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", "Copy descriptor dest update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].dstBinding, DSstr.c_str()); } else { srcStartIndex = getUpdateStartIndex(my_data, device, pSrcLayout, pCDS[i].srcBinding, pCDS[i].srcArrayElement, (const GENERIC_HEADER*)&(pCDS[i])); @@ -2070,7 +2070,7 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t descript for (uint32_t j=0; jdescriptorTypes[srcStartIndex+j] != pDstLayout->descriptorTypes[dstStartIndex+j]) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", "Copy descriptor update index %u, update count #%u, has src update descriptor type %s that does not match overlapping dest descriptor type of %s!", i, j+1, string_VkDescriptorType(pSrcLayout->descriptorTypes[srcStartIndex+j]), string_VkDescriptorType(pDstLayout->descriptorTypes[dstStartIndex+j])); } else { @@ -2093,7 +2093,7 @@ static VkBool32 validate_descriptor_availability_in_pool(layer_data* dev_data, D for (i=0; ireport_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS", "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocateDescriptorSets() call", (uint64_t) pSetLayouts[i]); } else { uint32_t typeIndex = 0, poolSizeCount = 0; @@ -2101,7 +2101,7 @@ static VkBool32 validate_descriptor_availability_in_pool(layer_data* dev_data, D typeIndex = static_cast(pLayout->createInfo.pBinding[j].descriptorType); poolSizeCount = pLayout->createInfo.pBinding[j].descriptorCount; if (poolSizeCount > pPoolNode->availableDescriptorTypeCount[typeIndex]) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pLayout->layout, 0, DRAWSTATE_DESCRIPTOR_POOL_EMPTY, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pLayout->layout, 0, DRAWSTATE_DESCRIPTOR_POOL_EMPTY, "DS", "Unable to allocate %u descriptors of type %s from pool %#" PRIxLEAST64 ". This pool only has %u descriptors of this type remaining.", poolSizeCount, string_VkDescriptorType(pLayout->createInfo.pBinding[j].descriptorType), (uint64_t) pPoolNode->pool, pPoolNode->availableDescriptorTypeCount[typeIndex]); } else { // Decrement available descriptors of this type @@ -2233,7 +2233,7 @@ static void clearDescriptorPool(layer_data* my_data, const VkDevice device, cons { DESCRIPTOR_POOL_NODE* pPool = getPoolNode(my_data, pool); if (!pPool) { - log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pool, 0, DRAWSTATE_INVALID_POOL, "DS", + log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pool, 0, DRAWSTATE_INVALID_POOL, "DS", "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkResetDescriptorPool() call", (uint64_t) pool); } else { // TODO: validate flags @@ -2256,7 +2256,7 @@ static GLOBAL_CB_NODE* getCBNode(layer_data* my_data, const VkCommandBuffer cb) if (my_data->commandBufferMap.count(cb) == 0) { loader_platform_thread_unlock_mutex(&globalLock); // TODO : How to pass cb as srcObj here? - log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", + log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", "Attempt to use CommandBuffer %#" PRIxLEAST64 " that doesn't exist!", reinterpret_cast(cb)); return NULL; } @@ -2286,7 +2286,7 @@ static void deleteCommandBuffers(layer_data* my_data) static VkBool32 report_error_no_cb_begin(const layer_data* dev_data, const VkCommandBuffer cb, const char* caller_name) { // TODO : How to pass cb as srcObj here? - return log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_BEGIN_COMMAND_BUFFER, "DS", + return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_BEGIN_COMMAND_BUFFER, "DS", "You must call vkBeginCommandBuffer() before this call to %s", caller_name); } @@ -2294,11 +2294,11 @@ bool validateCmdsInCmdBuffer(const layer_data* dev_data, const GLOBAL_CB_NODE* p bool skip_call = false; for (auto cmd : pCB->pCmds) { if (cmd_type == CMD_EXECUTECOMMANDS && cmd->type != CMD_EXECUTECOMMANDS) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", "vkCmdExecuteCommands() cannot be called on a cmd buffer with exsiting commands."); } if (cmd_type != CMD_EXECUTECOMMANDS && cmd->type == CMD_EXECUTECOMMANDS) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", "Commands cannot be added to a cmd buffer with exsiting secondary commands."); } } @@ -2317,7 +2317,7 @@ static VkBool32 addCmd(const layer_data* my_data, GLOBAL_CB_NODE* pCB, const CMD pCB->pCmds.push_back(pCmd); } else { // TODO : How to pass cb as srcObj here? - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", "Out of memory while attempting to allocate new CMD_NODE for commandBuffer %#" PRIxLEAST64, reinterpret_cast(pCB->commandBuffer)); } return skipCall; @@ -2438,7 +2438,7 @@ static VkBool32 printPipeline(layer_data* my_data, const VkCommandBuffer cb) if (!pPipeTrav) { // nothing to print } else { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", "%s", vk_print_vkgraphicspipelinecreateinfo(&pPipeTrav->graphicsPipelineCI, "{DS}").c_str()); } } @@ -2455,39 +2455,39 @@ static VkBool32 printDSConfig(layer_data* my_data, const VkCommandBuffer cb) SET_NODE* pSet = getSetNode(my_data, pCB->lastBoundDescriptorSet); DESCRIPTOR_POOL_NODE* pPool = getPoolNode(my_data, pSet->pool); // Print out pool details - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", "Details for pool %#" PRIxLEAST64 ".", (uint64_t) pPool->pool); string poolStr = vk_print_vkdescriptorpoolcreateinfo(&pPool->createInfo, " "); - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", "%s", poolStr.c_str()); // Print out set details char prefix[10]; uint32_t index = 0; - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", "Details for descriptor set %#" PRIxLEAST64 ".", (uint64_t) pSet->set); LAYOUT_NODE* pLayout = pSet->pLayout; // Print layout details - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", "Layout #%u, (object %#" PRIxLEAST64 ") for DS %#" PRIxLEAST64 ".", index+1, reinterpret_cast(pLayout->layout), reinterpret_cast(pSet->set)); sprintf(prefix, " [L%u] ", index); string DSLstr = vk_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, prefix).c_str(); - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", "%s", DSLstr.c_str()); index++; GENERIC_HEADER* pUpdate = pSet->pUpdateStructs; if (pUpdate) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", "Update Chain [UC] for descriptor set %#" PRIxLEAST64 ":", (uint64_t) pSet->set); sprintf(prefix, " [UC] "); - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", "%s", dynamic_display(pUpdate, prefix).c_str()); // TODO : If there is a "view" associated with this update, print CI for that view } else { if (0 != pSet->descriptorCount) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", "No Update Chain for descriptor set %#" PRIxLEAST64 " which has %u descriptors (vkUpdateDescriptors has not been called)", (uint64_t) pSet->set, pSet->descriptorCount); } else { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", "FYI: No descriptors in descriptor set %#" PRIxLEAST64 ".", (uint64_t) pSet->set); } } @@ -2499,12 +2499,12 @@ static void printCB(layer_data* my_data, const VkCommandBuffer cb) { GLOBAL_CB_NODE* pCB = getCBNode(my_data, cb); if (pCB && pCB->pCmds.size() > 0) { - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS", "Cmds in CB %p", (void*)cb); vector pCmds = pCB->pCmds; for (auto ii=pCmds.begin(); ii!=pCmds.end(); ++ii) { // TODO : Need to pass cb as srcObj here - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS", " CMD#%" PRIu64 ": %s", (*ii)->cmdNumber, cmdTypeToString((*ii)->type).c_str()); } } else { @@ -2515,7 +2515,7 @@ static void printCB(layer_data* my_data, const VkCommandBuffer cb) static VkBool32 synchAndPrintDSConfig(layer_data* my_data, const VkCommandBuffer cb) { VkBool32 skipCall = VK_FALSE; - if (!(my_data->report_data->active_flags & VK_DBG_REPORT_INFO_BIT)) { + if (!(my_data->report_data->active_flags & VK_DEBUG_REPORT_INFO_BIT)) { return skipCall; } skipCall |= printDSConfig(my_data, cb); @@ -2529,7 +2529,7 @@ static VkBool32 insideRenderPass(const layer_data* my_data, GLOBAL_CB_NODE *pCB, { VkBool32 inside = VK_FALSE; if (pCB->activeRenderPass) { - inside = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + inside = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)pCB->commandBuffer, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS", "%s: It is invalid to issue this call inside an active render pass (%#" PRIxLEAST64 ")", apiName, (uint64_t) pCB->activeRenderPass); @@ -2543,7 +2543,7 @@ static VkBool32 outsideRenderPass(const layer_data* my_data, GLOBAL_CB_NODE *pCB { VkBool32 outside = VK_FALSE; if (!pCB->activeRenderPass) { - outside = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + outside = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)pCB->commandBuffer, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS", "%s: This call must be issued inside an active render pass.", apiName); } @@ -2779,11 +2779,11 @@ bool ValidateCmdBufImageLayouts(VkCommandBuffer cmdBuffer) { for (auto cb_image_data : pCB->imageLayoutMap) { auto image_data = dev_data->imageLayoutMap.find(cb_image_data.first); if (image_data == dev_data->imageLayoutMap.end()) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Cannot submit cmd buffer using deleted image %" PRIu64 ".", reinterpret_cast(cb_image_data.first)); } else { if (dev_data->imageLayoutMap[cb_image_data.first]->layout != cb_image_data.second.initialLayout) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Cannot submit cmd buffer using image with layout %d when first use is %d.", dev_data->imageLayoutMap[cb_image_data.first]->layout, cb_image_data.second.initialLayout); } dev_data->imageLayoutMap[cb_image_data.first]->layout = cb_image_data.second.layout; @@ -2810,14 +2810,14 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint loader_platform_thread_lock_mutex(&globalLock); pCB->submitCount++; // increment submit count if ((pCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT) && (pCB->submitCount > 1)) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION, "DS", "CB %#" PRIxLEAST64 " was begun w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted %#" PRIxLEAST64 " times.", reinterpret_cast(pCB->commandBuffer), pCB->submitCount); } if (CB_RECORDED != pCB->state) { // Flag error for using CB w/o vkEndCommandBuffer() called // TODO : How to pass cb as srcObj? - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_END_COMMAND_BUFFER, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NO_END_COMMAND_BUFFER, "DS", "You must call vkEndCommandBuffer() on CB %#" PRIxLEAST64 " before this call to vkQueueSubmit()!", reinterpret_cast(pCB->commandBuffer)); loader_platform_thread_unlock_mutex(&globalLock); return VK_ERROR_VALIDATION_FAILED; @@ -3222,7 +3222,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDev // TODOSC : Capture layout bindings set LAYOUT_NODE* pNewNode = new LAYOUT_NODE; if (NULL == pNewNode) { - if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", + if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", "Out of memory while attempting to allocate LAYOUT_NODE in vkCreateDescriptorSetLayout()")) return VK_ERROR_VALIDATION_FAILED; } @@ -3235,7 +3235,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDev uint32_t totalCount = 0; for (uint32_t i=0; ibindingCount; i++) { if (!pNewNode->bindings.insert(pCreateInfo->pBinding[i].binding).second) { - if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) *pSetLayout, 0, DRAWSTATE_INVALID_LAYOUT, "DS", + if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) *pSetLayout, 0, DRAWSTATE_INVALID_LAYOUT, "DS", "duplicated binding number in VkDescriptorSetLayoutBinding")) return VK_ERROR_VALIDATION_FAILED; } @@ -3304,13 +3304,13 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice d VkResult result = dev_data->device_dispatch_table->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); if (VK_SUCCESS == result) { // Insert this pool into Global Pool LL at head - if (log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", + if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", "Created Descriptor Pool %#" PRIxLEAST64, (uint64_t) *pDescriptorPool)) return VK_ERROR_VALIDATION_FAILED; loader_platform_thread_lock_mutex(&globalLock); DESCRIPTOR_POOL_NODE* pNewNode = new DESCRIPTOR_POOL_NODE(*pDescriptorPool, pCreateInfo); if (NULL == pNewNode) { - if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", + if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS", "Out of memory while attempting to allocate DESCRIPTOR_POOL_NODE in vkCreateDescriptorPool()")) return VK_ERROR_VALIDATION_FAILED; } else { @@ -3340,7 +3340,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice // Verify that requested descriptorSets are available in pool DESCRIPTOR_POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocateInfo->descriptorPool); if (!pPoolNode) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pAllocateInfo->descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pAllocateInfo->descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS", "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocateDescriptorSets() call", (uint64_t) pAllocateInfo->descriptorPool); } else { // Make sure pool has all the available descriptors before calling down chain skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, pAllocateInfo->setLayoutCount, pAllocateInfo->pSetLayouts); @@ -3352,16 +3352,16 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice DESCRIPTOR_POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocateInfo->descriptorPool); if (pPoolNode) { if (pAllocateInfo->setLayoutCount == 0) { - log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pAllocateInfo->setLayoutCount, 0, DRAWSTATE_NONE, "DS", + log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pAllocateInfo->setLayoutCount, 0, DRAWSTATE_NONE, "DS", "AllocateDescriptorSets called with 0 count"); } for (uint32_t i = 0; i < pAllocateInfo->setLayoutCount; i++) { - log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", + log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", "Created Descriptor Set %#" PRIxLEAST64, (uint64_t) pDescriptorSets[i]); // Create new set node and add to head of pool nodes SET_NODE* pNewNode = new SET_NODE; if (NULL == pNewNode) { - if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS", + if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS", "Out of memory while attempting to allocate SET_NODE in vkAllocateDescriptorSets()")) return VK_ERROR_VALIDATION_FAILED; } else { @@ -3374,7 +3374,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice pPoolNode->pSets = pNewNode; LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pAllocateInfo->pSetLayouts[i]); if (NULL == pLayout) { - if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pAllocateInfo->pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS", + if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pAllocateInfo->pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS", "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocateDescriptorSets() call", (uint64_t) pAllocateInfo->pSetLayouts[i])) return VK_ERROR_VALIDATION_FAILED; } @@ -3402,7 +3402,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice dev DESCRIPTOR_POOL_NODE *pPoolNode = getPoolNode(dev_data, descriptorPool); if (pPoolNode && !(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT & pPoolNode->createInfo.flags)) { // Can't Free from a NON_FREE pool - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, (uint64_t)device, 0, DRAWSTATE_CANT_FREE_FROM_NON_FREE_POOL, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, (uint64_t)device, 0, DRAWSTATE_CANT_FREE_FROM_NON_FREE_POOL, "DS", "It is invalid to call vkFreeDescriptorSets() with a pool created without setting VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT."); } if (skipCall) @@ -3468,31 +3468,31 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuf if (pCB->createInfo.level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) { if (pBeginInfo->renderPass || pBeginInfo->framebuffer) { // These should be NULL for a Primary CB - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", "vkBeginCommandBuffer(): Primary Command Buffer (%p) may not specify framebuffer or renderpass parameters", (void*)commandBuffer); } } else { if (!pBeginInfo->renderPass || !pBeginInfo->framebuffer) { // These should NOT be null for an Secondary CB - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", "vkBeginCommandBuffer(): Secondary Command Buffers (%p) must specify framebuffer and renderpass parameters", (void*)commandBuffer); } } pCB->beginInfo = *pBeginInfo; if (CB_RECORDING == pCB->state) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", "vkBeginCommandBuffer(): Cannot call Begin on CB (%#" PRIxLEAST64 ") in the RECORDING state. Must first call vkEndCommandBuffer().", (uint64_t)commandBuffer); } else if (CB_RECORDED == pCB->state) { VkCommandPool cmdPool = pCB->createInfo.commandPool; if (!(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT & dev_data->commandPoolMap[cmdPool].createFlags)) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_INVALID_COMMAND_BUFFER_RESET, "DS", "Call to vkBeginCommandBuffer() on command buffer (%#" PRIxLEAST64 ") attempts to implicitly reset cmdBuffer created from command pool (%#" PRIxLEAST64 ") that does NOT have the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT bit set.", (uint64_t) commandBuffer, (uint64_t) cmdPool); } } } else { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", "In vkBeginCommandBuffer() and unable to find CommandBuffer Node for CB %p!", (void*)commandBuffer); } if (skipCall) { @@ -3540,7 +3540,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuf GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer); VkCommandPool cmdPool = pCB->createInfo.commandPool; if (!(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT & dev_data->commandPoolMap[cmdPool].createFlags)) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t) commandBuffer, + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t) commandBuffer, 0, DRAWSTATE_INVALID_COMMAND_BUFFER_RESET, "DS", "Attempt to reset command buffer (%#" PRIxLEAST64 ") created from command pool (%#" PRIxLEAST64 ") that does NOT have the VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT bit set.", (uint64_t) commandBuffer, (uint64_t) cmdPool); @@ -3563,12 +3563,12 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer com if (pCB->state == CB_RECORDING) { skipCall |= addCmd(dev_data, pCB, CMD_BINDPIPELINE); if ((VK_PIPELINE_BIND_POINT_COMPUTE == pipelineBindPoint) && (pCB->activeRenderPass)) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline, + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS", "Incorrectly binding compute pipeline (%#" PRIxLEAST64 ") during active RenderPass (%#" PRIxLEAST64 ")", (uint64_t) pipeline, (uint64_t) pCB->activeRenderPass); } else if ((VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) && (!pCB->activeRenderPass)) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline, + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS", "Incorrectly binding graphics pipeline " " (%#" PRIxLEAST64 ") without an active RenderPass", (uint64_t) pipeline); } else { @@ -3581,7 +3581,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer com loader_platform_thread_unlock_mutex(&globalLock); skipCall |= validatePipelineState(dev_data, pCB, pipelineBindPoint, pipeline); } else { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline, + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline, 0, DRAWSTATE_INVALID_PIPELINE, "DS", "Attempt to bind Pipeline %#" PRIxLEAST64 " that doesn't exist!", reinterpret_cast(pipeline)); } @@ -3815,10 +3815,10 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuff if (pCB) { if (pCB->state == CB_RECORDING) { if ((VK_PIPELINE_BIND_POINT_COMPUTE == pipelineBindPoint) && (pCB->activeRenderPass)) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS", "Incorrectly binding compute DescriptorSets during active RenderPass (%#" PRIxLEAST64 ")", (uint64_t) pCB->activeRenderPass); } else if ((VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) && (!pCB->activeRenderPass)) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS", "Incorrectly binding graphics DescriptorSets without an active RenderPass"); } else { // Track total count of dynamic descriptor types to make sure we have an offset for each one @@ -3836,20 +3836,20 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuff pCB->lastBoundPipelineLayout = layout; pCB->boundDescriptorSets[i+firstSet] = pDescriptorSets[i]; loader_platform_thread_unlock_mutex(&globalLock); - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", "DS %#" PRIxLEAST64 " bound on pipeline %s", (uint64_t) pDescriptorSets[i], string_VkPipelineBindPoint(pipelineBindPoint)); if (!pSet->pUpdateStructs) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, "DS", "DS %#" PRIxLEAST64 " bound but it was never updated. You may want to either update it or not bind it.", (uint64_t) pDescriptorSets[i]); } // Verify that set being bound is compatible with overlapping setLayout of pipelineLayout if (!verify_set_layout_compatibility(dev_data, pSet, layout, i+firstSet, errorString)) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_PIPELINE_LAYOUTS_INCOMPATIBLE, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_PIPELINE_LAYOUTS_INCOMPATIBLE, "DS", "descriptorSet #%u being bound is not compatible with overlapping layout in pipelineLayout due to: %s", i, errorString.c_str()); } totalDynamicDescriptors += pSet->pLayout->dynamicDescriptorCount; } else { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_INVALID_SET, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_INVALID_SET, "DS", "Attempt to bind DS %#" PRIxLEAST64 " that doesn't exist!", (uint64_t) pDescriptorSets[i]); } } @@ -3858,7 +3858,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuff if (firstSet > 0) { // Check set #s below the first bound set for (uint32_t i=0; iboundDescriptorSets[i] && !verify_set_layout_compatibility(dev_data, dev_data->setMap[pCB->boundDescriptorSets[i]], layout, i, errorString)) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_PERF_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pCB->boundDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERF_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pCB->boundDescriptorSets[i], 0, DRAWSTATE_NONE, "DS", "DescriptorSetDS %#" PRIxLEAST64 " previously bound as set #%u was disturbed by newly bound pipelineLayout (%#" PRIxLEAST64 ")", (uint64_t) pCB->boundDescriptorSets[i], i, (uint64_t) layout); pCB->boundDescriptorSets[i] = VK_NULL_HANDLE; } @@ -3867,14 +3867,14 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuff // Check if newly last bound set invalidates any remaining bound sets if ((pCB->boundDescriptorSets.size()-1) > (lastSetIndex)) { if (oldFinalBoundSet && !verify_set_layout_compatibility(dev_data, dev_data->setMap[oldFinalBoundSet], layout, lastSetIndex, errorString)) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_PERF_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) oldFinalBoundSet, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERF_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) oldFinalBoundSet, 0, DRAWSTATE_NONE, "DS", "DescriptorSetDS %#" PRIxLEAST64 " previously bound as set #%u is incompatible with set %#" PRIxLEAST64 " newly bound as set #%u so set #%u and any subsequent sets were disturbed by newly bound pipelineLayout (%#" PRIxLEAST64 ")", (uint64_t) oldFinalBoundSet, lastSetIndex, (uint64_t) pCB->boundDescriptorSets[lastSetIndex], lastSetIndex, lastSetIndex+1, (uint64_t) layout); pCB->boundDescriptorSets.resize(lastSetIndex+1); } } // dynamicOffsetCount must equal the total number of dynamic descriptors in the sets being bound if (totalDynamicDescriptors != dynamicOffsetCount) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t) commandBuffer, 0, DRAWSTATE_INVALID_DYNAMIC_OFFSET_COUNT, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t) commandBuffer, 0, DRAWSTATE_INVALID_DYNAMIC_OFFSET_COUNT, "DS", "Attempting to bind %u descriptorSets with %u dynamic descriptors, but dynamicOffsetCount is %u. It should exactly match the number of dynamic descriptors.", setCount, totalDynamicDescriptors, dynamicOffsetCount); } } @@ -3906,7 +3906,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer break; } if (!offset_align || (offset % offset_align)) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VTX_INDEX_ALIGNMENT_ERROR, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_VTX_INDEX_ALIGNMENT_ERROR, "DS", "vkCmdBindIndexBuffer() offset (%#" PRIxLEAST64 ") does not fall on alignment (%s) boundary.", offset, string_VkIndexType(indexType)); } } else { @@ -3952,7 +3952,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuff pCB->drawCount[DRAW]++; skipCall |= validate_draw_state(dev_data, pCB, VK_FALSE); // TODO : Need to pass commandBuffer as srcObj here - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS", "vkCmdDraw() call #%" PRIu64 ", reporting DS state:", g_drawCount[DRAW]++); skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer); if (VK_FALSE == skipCall) { @@ -3977,7 +3977,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer comm pCB->drawCount[DRAW_INDEXED]++; skipCall |= validate_draw_state(dev_data, pCB, VK_TRUE); // TODO : Need to pass commandBuffer as srcObj here - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS", "vkCmdDrawIndexed() call #%" PRIu64 ", reporting DS state:", g_drawCount[DRAW_INDEXED]++); skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer); if (VK_FALSE == skipCall) { @@ -4002,7 +4002,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer com pCB->drawCount[DRAW_INDIRECT]++; skipCall |= validate_draw_state(dev_data, pCB, VK_FALSE); // TODO : Need to pass commandBuffer as srcObj here - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS", "vkCmdDrawIndirect() call #%" PRIu64 ", reporting DS state:", g_drawCount[DRAW_INDIRECT]++); skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer); if (VK_FALSE == skipCall) { @@ -4027,7 +4027,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuf pCB->drawCount[DRAW_INDEXED_INDIRECT]++; skipCall |= validate_draw_state(dev_data, pCB, VK_TRUE); // TODO : Need to pass commandBuffer as srcObj here - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_NONE, "DS", "vkCmdDrawIndexedIndirect() call #%" PRIu64 ", reporting DS state:", g_drawCount[DRAW_INDEXED_INDIRECT]++); skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer); if (VK_FALSE == skipCall) { @@ -4110,15 +4110,15 @@ bool VerifySourceImageLayout(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImag return false; } if (src_image_element->second.layout != srcImageLayout) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Cannot copy from an image whose source layout is %d and doesn't match the current layout %d.", srcImageLayout, src_image_element->second.layout); } if (srcImageLayout != VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) { if (srcImageLayout == VK_IMAGE_LAYOUT_GENERAL) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Layout for input image should be TRANSFER_SRC_OPTIMAL instead of GENERAL."); } else { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Layout for input image is %d but can only be TRANSFER_SRC_OPTIMAL or GENERAL.", srcImageLayout); } } @@ -4142,15 +4142,15 @@ bool VerifyDestImageLayout(VkCommandBuffer cmdBuffer, VkImage destImage, VkImage return false; } if (dest_image_element->second.layout != destImageLayout) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Cannot copy from an image whose dest layout is %d and doesn't match the current layout %d.", destImageLayout, dest_image_element->second.layout); } if (destImageLayout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) { if (destImageLayout == VK_IMAGE_LAYOUT_GENERAL) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Layout for output image should be TRANSFER_DST_OPTIMAL instead of GENERAL."); } else { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Layout for output image is %d but can only be TRANSFER_DST_OPTIMAL or GENERAL.", destImageLayout); } } @@ -4295,7 +4295,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( (pCB->activeRenderPassBeginInfo.renderArea.extent.width == pRects[0].rect.extent.width) && (pCB->activeRenderPassBeginInfo.renderArea.extent.height == pRects[0].rect.extent.height)) { // TODO : commandBuffer should be srcObj - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, "DS", "vkCmdClearAttachments() issued on CB object 0x%" PRIxLEAST64 " prior to any Draw Cmds." " It is recommended you use RenderPass LOAD_OP_CLEAR on Attachments prior to any Draw.", reinterpret_cast(commandBuffer)); } @@ -4322,7 +4322,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( } } if (VK_FALSE == found) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS", "vkCmdClearAttachments() attachment index %d not found in attachment reference array of active subpass %d", attachment->colorAttachment, pCB->activeSubpass); @@ -4331,7 +4331,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( if (!pSD->pDepthStencilAttachment || // Says no DS will be used in active subpass (pSD->pDepthStencilAttachment->attachment == VK_ATTACHMENT_UNUSED)) { // Says no DS will be used in active subpass - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS", "vkCmdClearAttachments() attachment index %d does not match depthStencilAttachment.attachment (%d) found in active subpass %d", attachment->colorAttachment, @@ -4462,7 +4462,7 @@ bool TransitionImageLayouts(VkCommandBuffer cmdBuffer, uint32_t memBarrierCount, pCB->imageLayoutMap[image_mem_barrier->image].layout = image_mem_barrier->newLayout; } else { if (image_data->second.layout != image_mem_barrier->oldLayout) { - skip |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "You cannot transition the layout from %s when current layout is %s.", string_VkImageLayout(image_mem_barrier->oldLayout), string_VkImageLayout(image_data->second.layout)); } @@ -4479,16 +4479,16 @@ bool ValidateMaskBits(const layer_data* my_data, VkCommandBuffer cmdBuffer, cons bool skip_call = false; if ((accessMask & required_bit) || (!required_bit && (accessMask & optional_bits))) { if (accessMask & !(required_bit | optional_bits)) { - skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", "Additional bits in accessMask %d are specified when layout is %s.", accessMask, string_VkImageLayout(layout)); } } else { if (!required_bit) { - skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", "AccessMask %d must contain at least one of access bits %d when layout is %s.", accessMask, optional_bits, string_VkImageLayout(layout)); } else { - skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", "AccessMask %d must have required access bit %d and may have optional bits %d when layout is %s.", accessMask, required_bit, optional_bits,string_VkImageLayout(layout)); } @@ -4529,7 +4529,7 @@ bool ValidateMaskBitsFromLayouts(const layer_data* my_data, VkCommandBuffer cmdB } case VK_IMAGE_LAYOUT_UNDEFINED: { if (accessMask != 0) { - skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", "Additional bits in accessMask %d are specified when layout is %s.", accessMask, string_VkImageLayout(layout)); } break; @@ -4550,12 +4550,12 @@ bool ValidateBarriers(VkCommandBuffer cmdBuffer, uint32_t memBarrierCount, const for (uint32_t i = 0; i < memBarrierCount; ++i) { auto mem_barrier = reinterpret_cast(ppMemBarriers[i]); if (mem_barrier && mem_barrier->sType != VK_STRUCTURE_TYPE_MEMORY_BARRIER) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", "Image or Buffers Barriers cannot be used during a render pass."); } } if (!dev_data->renderPassMap[pCB->activeRenderPass]->hasSelfDependency[pCB->activeSubpass]) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_BARRIER, "DS", "Barriers cannot be set during subpass %d with no self dependency specified.", pCB->activeSubpass); } } @@ -4749,11 +4749,11 @@ VkBool32 CheckDependencyExists(const layer_data* my_data, VkDevice device, const std::unordered_set processed_nodes; if (FindDependency(subpass, dependent_subpasses[k], subpass_to_node, processed_nodes) || FindDependency(dependent_subpasses[k], subpass, subpass_to_node, processed_nodes)) { - skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", "A dependency between subpasses %d and %d must exist but only an implicit one is specified.", subpass, dependent_subpasses[k]); } else { - skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", "A dependency between subpasses %d and %d must exist but one is not specified.", subpass, dependent_subpasses[k]); result = false; @@ -4792,7 +4792,7 @@ VkBool32 CheckPreserved(const layer_data* my_data, VkDevice device, const VkRend } } if (!has_preserved) { - skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", "Attachment %d is used by a later subpass and must be preserved in subpass %d.", attachment, index); } } @@ -4812,7 +4812,7 @@ VkBool32 ValidateDependencies(const layer_data* my_data, VkDevice device, const for (uint32_t i = 0; i < pCreateInfo->dependencyCount; ++i) { const VkSubpassDependency& dependency = pCreateInfo->pDependencies[i]; if (dependency.srcSubpass > dependency.dstSubpass) { - skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", "Dependency graph must be specified such that an earlier pass cannot depend on a later pass."); } subpass_to_node[dependency.dstSubpass].prev.push_back(dependency.srcSubpass); @@ -4875,10 +4875,10 @@ bool ValidateLayouts(const layer_data* my_data, VkDevice device, const VkRenderP if (subpass.pInputAttachments[j].layout != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL && subpass.pInputAttachments[j].layout != VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) { if (subpass.pInputAttachments[j].layout == VK_IMAGE_LAYOUT_GENERAL) { - skip |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Layout for input attachment is GENERAL but should be READ_ONLY_OPTIMAL."); } else { - skip |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Layout for input attachment is %d but can only be READ_ONLY_OPTIMAL or GENERAL.", subpass.pInputAttachments[j].attachment); } } @@ -4886,10 +4886,10 @@ bool ValidateLayouts(const layer_data* my_data, VkDevice device, const VkRenderP for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) { if (subpass.pColorAttachments[j].layout != VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) { if (subpass.pColorAttachments[j].layout == VK_IMAGE_LAYOUT_GENERAL) { - skip |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Layout for color attachment is GENERAL but should be COLOR_ATTACHMENT_OPTIMAL."); } else { - skip |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Layout for color attachment is %d but can only be COLOR_ATTACHMENT_OPTIMAL or GENERAL.", subpass.pColorAttachments[j].attachment); } } @@ -4898,10 +4898,10 @@ bool ValidateLayouts(const layer_data* my_data, VkDevice device, const VkRenderP (subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED)) { if (subpass.pDepthStencilAttachment->layout != VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) { if (subpass.pDepthStencilAttachment->layout == VK_IMAGE_LAYOUT_GENERAL) { - skip |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Layout for depth attachment is GENERAL but should be DEPTH_STENCIL_ATTACHMENT_OPTIMAL."); } else { - skip |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Layout for depth attachment is %d but can only be DEPTH_STENCIL_ATTACHMENT_OPTIMAL or GENERAL.", subpass.pDepthStencilAttachment->attachment); } } @@ -4919,7 +4919,7 @@ bool CreatePassDAG(const layer_data* my_data, VkDevice device, const VkRenderPas for (uint32_t i = 0; i < pCreateInfo->dependencyCount; ++i) { const VkSubpassDependency& dependency = pCreateInfo->pDependencies[i]; if (dependency.srcSubpass > dependency.dstSubpass) { - skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", "Depedency graph must be specified such that an earlier pass cannot depend on a later pass."); } else if (dependency.srcSubpass == dependency.dstSubpass) { has_self_dependency[dependency.srcSubpass] = true; @@ -4940,7 +4940,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); bool skip_call = false; if (!shader_is_spirv(pCreateInfo)) { - skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, /* dev */ 0, 0, SHADER_CHECKER_NON_SPIRV_SHADER, "SC", "Shader is not SPIR-V"); } @@ -5074,7 +5074,7 @@ bool VerifyFramebufferAndRenderPassLayouts(VkCommandBuffer cmdBuffer, const VkRe const VkRenderPassCreateInfo* pRenderPassInfo = dev_data->renderPassMap[pRenderPassBegin->renderPass]->pCreateInfo; const VkFramebufferCreateInfo* pFramebufferInfo = dev_data->frameBufferMap[pRenderPassBegin->framebuffer]; if (pRenderPassInfo->attachmentCount != pFramebufferInfo->attachmentCount) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", "You cannot start a render pass using a framebuffer with a different number of attachments."); } for (uint32_t i = 0; i < pRenderPassInfo->attachmentCount; ++i) { @@ -5085,7 +5085,7 @@ bool VerifyFramebufferAndRenderPassLayouts(VkCommandBuffer cmdBuffer, const VkRe pCB->imageLayoutMap[image].initialLayout = pRenderPassInfo->pAttachments[i].initialLayout; pCB->imageLayoutMap[image].layout = pRenderPassInfo->pAttachments[i].initialLayout; } else if (pRenderPassInfo->pAttachments[i].initialLayout != image_data->second.layout) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", "You cannot start a render pass using attachment %i where the intial layout differs from the starting layout.", i); } } @@ -5142,7 +5142,7 @@ void TransitionSubpassLayouts(VkCommandBuffer cmdBuffer, const VkRenderPassBegin bool validatePrimaryCommandBuffer(const layer_data* my_data, const GLOBAL_CB_NODE* pCB, const std::string& cmd_name) { bool skip_call = false; if (pCB->createInfo.level != VK_COMMAND_BUFFER_LEVEL_PRIMARY) { - skip_call |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", "Cannot execute command %s on a secondary command buffer.", cmd_name.c_str()); } return skip_call; @@ -5193,7 +5193,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer skipCall |= validatePipelineState(dev_data, pCB, VK_PIPELINE_BIND_POINT_GRAPHICS, pCB->lastBoundPipeline); } } else { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_RENDERPASS, "DS", "You cannot use a NULL RenderPass object in vkCmdBeginRenderPass()"); } } @@ -5253,10 +5253,10 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer for (uint32_t i=0; ireport_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS", "vkCmdExecuteCommands() called w/ invalid Cmd Buffer %p in element %u of pCommandBuffers array.", (void*)pCommandBuffers[i], i); } else if (VK_COMMAND_BUFFER_LEVEL_PRIMARY == pSubCB->createInfo.level) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS", "vkCmdExecuteCommands() called w/ Primary Cmd Buffer %p in element %u of pCommandBuffers array. All cmd buffers in pCommandBuffers array must be secondary.", (void*)pCommandBuffers[i], i); } } @@ -5275,7 +5275,7 @@ bool ValidateMapImageLayouts(VkDevice device, VkDeviceMemory mem) { auto image_data = dev_data->imageLayoutMap.find(mem_data->second); if (image_data != dev_data->imageLayoutMap.end()) { if (image_data->second->layout != VK_IMAGE_LAYOUT_PREINITIALIZED && image_data->second->layout != VK_IMAGE_LAYOUT_GENERAL) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Cannot map an image with layout %d. Only GENERAL or PREINITIALIZED are supported.", image_data->second->layout); } } @@ -5399,7 +5399,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, auto image_data = dev_data->imageLayoutMap.find(image); if (image_data != dev_data->imageLayoutMap.end()) { if (image_data->second->layout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) { - skip_call |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, (uint64_t)queue, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, (uint64_t)queue, 0, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", "Images passed to present must be in layout PRESENT_SOURCE_KHR but is in %d", image_data->second->layout); } } @@ -5444,7 +5444,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDbgMarkerBegin(VkCommandBuffer c layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer); if (!dev_data->device_extensions.debug_marker_enabled) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS", "Attempt to use CmdDbgMarkerBegin but extension disabled!"); return; } else if (pCB) { @@ -5461,7 +5461,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDbgMarkerEnd(VkCommandBuffer com layer_data* dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE* pCB = getCBNode(dev_data, commandBuffer); if (!dev_data->device_extensions.debug_marker_enabled) { - skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS", + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, DRAWSTATE_INVALID_EXTENSION, "DS", "Attempt to use CmdDbgMarkerEnd but extension disabled!"); return; } else if (pCB) { diff --git a/layers/image.cpp b/layers/image.cpp index 811467f5..0210d5b8 100644 --- a/layers/image.cpp +++ b/layers/image.cpp @@ -285,7 +285,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, co if ((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0)) { char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, contains unsupported format"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_FORMAT_UNSUPPORTED, "IMAGE", str); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_FORMAT_UNSUPPORTED, "IMAGE", str); } } @@ -300,7 +300,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, co if ((pCreateInfo->extent.depth > ImageFormatProperties.maxExtent.depth) || (pCreateInfo->extent.width > ImageFormatProperties.maxExtent.width) || (pCreateInfo->extent.height > ImageFormatProperties.maxExtent.height)) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pImage, 0, + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pImage, 0, IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", "CreateImage extents exceed allowable limits for format: " "Width = %d Height = %d Depth = %d: Limits for Width = %d Height = %d Depth = %d for format %s.", @@ -319,7 +319,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, co (uint64_t)imageGranularity ) & ~(uint64_t)imageGranularity; if (totalSize > ImageFormatProperties.maxResourceSize) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pImage, 0, + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pImage, 0, IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", "CreateImage resource size exceeds allowable maximum " "Image resource size = %#" PRIxLEAST64 ", maximum resource size = %#" PRIxLEAST64 " ", @@ -327,21 +327,21 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, co } if (pCreateInfo->mipLevels > ImageFormatProperties.maxMipLevels) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pImage, 0, + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pImage, 0, IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", "CreateImage mipLevels=%d exceeds allowable maximum supported by format of %d", pCreateInfo->mipLevels, ImageFormatProperties.maxMipLevels); } if (pCreateInfo->arrayLayers > ImageFormatProperties.maxArrayLayers) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pImage, 0, + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pImage, 0, IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", "CreateImage arrayLayers=%d exceeds allowable maximum supported by format of %d", pCreateInfo->arrayLayers, ImageFormatProperties.maxArrayLayers); } if ((pCreateInfo->samples & ImageFormatProperties.sampleCounts) == 0) { - skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pImage, 0, + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pImage, 0, IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", "CreateImage samples %s is not supported by format 0x%.8X", string_VkSampleCountFlagBits(pCreateInfo->samples), ImageFormatProperties.sampleCounts); @@ -379,7 +379,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice devic { std::stringstream ss; ss << "vkCreateRenderPass parameter, VkFormat in pCreateInfo->pAttachments[" << i << "], contains unsupported format"; - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_FORMAT_UNSUPPORTED, "IMAGE", "%s", ss.str().c_str()); + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_FORMAT_UNSUPPORTED, "IMAGE", "%s", ss.str().c_str()); } } } @@ -391,7 +391,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice devic { std::stringstream ss; ss << "vkCreateRenderPass parameter, VkImageLayout in pCreateInfo->pAttachments[" << i << "], is unrecognized"; - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); } } @@ -401,7 +401,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice devic { std::stringstream ss; ss << "vkCreateRenderPass parameter, VkAttachmentLoadOp in pCreateInfo->pAttachments[" << i << "], is unrecognized"; - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); } } @@ -411,7 +411,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice devic { std::stringstream ss; ss << "vkCreateRenderPass parameter, VkAttachmentStoreOp in pCreateInfo->pAttachments[" << i << "], is unrecognized"; - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); } } @@ -429,7 +429,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice devic pCreateInfo->pSubpasses[i].pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { std::stringstream ss; ss << "vkCreateRenderPass has no depth/stencil attachment, yet subpass[" << i << "] has VkSubpassDescription::depthStencilAttachment value that is not VK_ATTACHMENT_UNUSED"; - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_RENDERPASS_INVALID_DS_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_RENDERPASS_INVALID_DS_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); } } } @@ -451,23 +451,23 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device std::stringstream ss; ss << "vkCreateImageView called with baseMipLevel " << pCreateInfo->subresourceRange.baseMipLevel << " for image " << pCreateInfo->image << " that only has " << imageEntry->second.mipLevels << " mip levels."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); } if (pCreateInfo->subresourceRange.baseArrayLayer >= imageEntry->second.arraySize) { std::stringstream ss; ss << "vkCreateImageView called with baseArrayLayer " << pCreateInfo->subresourceRange.baseArrayLayer << " for image " << pCreateInfo->image << " that only has " << imageEntry->second.arraySize << " mip levels."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); } if (!pCreateInfo->subresourceRange.levelCount) { std::stringstream ss; ss << "vkCreateImageView called with 0 in pCreateInfo->subresourceRange.levelCount."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); } if (!pCreateInfo->subresourceRange.layerCount) { std::stringstream ss; ss << "vkCreateImageView called with 0 in pCreateInfo->subresourceRange.layerCount."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); } // Validate correct image aspect bits for desired formats and format consistency @@ -479,20 +479,20 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) { std::stringstream ss; ss << "vkCreateImageView: Color image formats must have the VK_IMAGE_ASPECT_COLOR_BIT set"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != aspectMask) { std::stringstream ss; ss << "vkCreateImageView: Color image formats must have ONLY the VK_IMAGE_ASPECT_COLOR_BIT set"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } if (VK_FALSE == vk_format_is_color(ivciFormat)) { std::stringstream ss; ss << "vkCreateImageView: The image view's format can differ from the parent image's format, but both must be " << "color formats. ImageFormat is " << string_VkFormat(imageFormat) << " ImageViewFormat is " << string_VkFormat(ivciFormat); - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_FORMAT, "IMAGE", "%s", ss.str().c_str()); } // TODO: Uncompressed formats are compatible if they occupy they same number of bits per pixel. @@ -502,39 +502,39 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) == 0) { std::stringstream ss; ss << "vkCreateImageView: Depth/stencil image formats must have at least one of VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != aspectMask) { std::stringstream ss; ss << "vkCreateImageView: Combination depth/stencil image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } else if (vk_format_is_depth_only(imageFormat)) { if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) { std::stringstream ss; ss << "vkCreateImageView: Depth-only image formats must have the VK_IMAGE_ASPECT_DEPTH_BIT set"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != aspectMask) { std::stringstream ss; ss << "vkCreateImageView: Depth-only image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT set"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } else if (vk_format_is_stencil_only(imageFormat)) { if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT) { std::stringstream ss; ss << "vkCreateImageView: Stencil-only image formats must have the VK_IMAGE_ASPECT_STENCIL_BIT set"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != aspectMask) { std::stringstream ss; ss << "vkCreateImageView: Stencil-only image formats can have only the VK_IMAGE_ASPECT_STENCIL_BIT set"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } @@ -561,7 +561,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( for (uint32_t i = 0; i < rangeCount; i++) { if (pRanges[i].aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) { char const str[] = "vkCmdClearColorImage aspectMasks for all subresource ranges must be set to VK_IMAGE_ASPECT_COLOR_BIT"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } @@ -589,7 +589,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( { char const str[] = "vkCmdClearDepthStencilImage aspectMasks for all subresource ranges must be " "set to VK_IMAGE_ASPECT_DEPTH_BIT and/or VK_IMAGE_ASPECT_STENCIL_BIT"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } @@ -622,33 +622,33 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( if(pRegions[i].srcSubresource.layerCount == 0) { char const str[] = "vkCmdCopyImage: number of layers in source subresource is zero"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } if(pRegions[i].dstSubresource.layerCount == 0) { char const str[] = "vkCmdCopyImage: number of layers in destination subresource is zero"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } if(pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount) { char const str[] = "vkCmdCopyImage: number of layers in source and destination subresources must match"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } if (pRegions[i].srcSubresource.aspectMask != pRegions[i].dstSubresource.aspectMask) { char const str[] = "vkCmdCopyImage: Src and dest aspectMasks for each region must match"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } if ((pRegions[i].srcSubresource.aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) && (pRegions[i].srcSubresource.aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) { char const str[] = "vkCmdCopyImage aspectMask cannot specify both COLOR and DEPTH/STENCIL aspects"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } @@ -657,14 +657,14 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( && (dstImageEntry != device_data->imageMap.end())) { if (srcImageEntry->second.imageType != dstImageEntry->second.imageType) { char const str[] = "vkCmdCopyImage called with unmatched source and dest image types."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str); } // Check that format is same size or exact stencil/depth if (is_depth_format(srcImageEntry->second.format)) { if (srcImageEntry->second.format != dstImageEntry->second.format) { char const str[] = "vkCmdCopyImage called with unmatched source and dest image depth/stencil formats."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str); } } else { @@ -672,7 +672,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( size_t destSize = vk_format_get_size(dstImageEntry->second.format); if (srcSize != destSize) { char const str[] = "vkCmdCopyImage called with unmatched source and dest image format sizes."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str); } } @@ -700,7 +700,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( if (aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) { // VK_IMAGE_ASPECT_COLOR_BIT is not the only bit set for this attachment char const str[] = "vkCmdClearAttachments aspectMask [%d] must set only VK_IMAGE_ASPECT_COLOR_BIT of a color attachment."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i); } } else { @@ -709,7 +709,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT)) { char const str[] = "vkCmdClearAttachments aspectMask [%d] must be set to VK_IMAGE_ASPECT_DEPTH_BIT and/or VK_IMAGE_ASPECT_STENCIL_BIT"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i); } } @@ -737,7 +737,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( if(pRegions[i].imageSubresource.layerCount == 0) { char const str[] = "vkCmdCopyImageToBuffer: number of layers in image subresource is zero"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } @@ -746,7 +746,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( (aspectMask != VK_IMAGE_ASPECT_DEPTH_BIT) && (aspectMask != VK_IMAGE_ASPECT_STENCIL_BIT)) { char const str[] = "vkCmdCopyImageToBuffer: aspectMasks for each region must specify only COLOR or DEPTH or STENCIL"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } @@ -773,7 +773,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( if(pRegions[i].imageSubresource.layerCount == 0) { char const str[] = "vkCmdCopyBufferToImage: number of layers in image subresource is zero"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } @@ -782,7 +782,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( (aspectMask != VK_IMAGE_ASPECT_DEPTH_BIT) && (aspectMask != VK_IMAGE_ASPECT_STENCIL_BIT)) { char const str[] = "vkCmdCopyBufferToImage: aspectMasks for each region must specify only COLOR or DEPTH or STENCIL"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } @@ -822,7 +822,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( ss << "vkCmdBlitImage: If one of srcImage and dstImage images has signed/unsigned integer format, " << "the other one must also have signed/unsigned integer format. " << "Source format is " << string_VkFormat(srcFormat) << " Destinatino format is " << string_VkFormat(dstFormat); - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", "%s", ss.str().c_str()); } @@ -834,7 +834,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( ss << "vkCmdBlitImage: If one of srcImage and dstImage images has a format of depth, stencil or depth " << "stencil, the other one must have exactly the same format. " << "Source format is " << string_VkFormat(srcFormat) << " Destinatino format is " << string_VkFormat(dstFormat); - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", "%s", ss.str().c_str()); } @@ -842,21 +842,21 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( if(pRegions[i].srcSubresource.layerCount == 0) { char const str[] = "vkCmdBlitImage: number of layers in source subresource is zero"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } if(pRegions[i].dstSubresource.layerCount == 0) { char const str[] = "vkCmdBlitImage: number of layers in destination subresource is zero"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } if(pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount) { char const str[] = "vkCmdBlitImage: number of layers in source and destination subresources must match"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } @@ -866,7 +866,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( if (srcAspect != dstAspect) { std::stringstream ss; ss << "vkCmdBlitImage: Image aspects of depth/stencil images should match"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } if (vk_format_is_depth_and_stencil(srcFormat)) { @@ -874,7 +874,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( std::stringstream ss; ss << "vkCmdBlitImage: Combination depth/stencil image formats must have both VK_IMAGE_ASPECT_DEPTH_BIT " << "and VK_IMAGE_ASPECT_STENCIL_BIT set in both the srcImage and dstImage"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } else if (vk_format_is_stencil_only(srcFormat)) { @@ -882,7 +882,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( std::stringstream ss; ss << "vkCmdBlitImage: Stencil-only image formats must have only the VK_IMAGE_ASPECT_STENCIL_BIT " << "set in both the srcImage and dstImage"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } else if (vk_format_is_depth_only(srcFormat)) { @@ -890,7 +890,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( std::stringstream ss; ss << "vkCmdBlitImage: Depth-only image formats must have only the VK_IMAGE_ASPECT_DEPTH " << "set in both the srcImage and dstImage"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } @@ -904,7 +904,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( std::stringstream ss; ss << "vkCmdBlitImage: If the format of srcImage is a depth, stencil, depth stencil or integer-based format " << "then filter must be VK_FILTER_NEAREST."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_FILTER, "IMAGE", "%s", ss.str().c_str()); } } @@ -934,7 +934,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( { std::stringstream ss; ss << "vkCmdPipelineBarrier called with 0 in ppMemoryBarriers[" << i << "]->subresourceRange.layerCount."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 0, "IMAGE", "%s", ss.str().c_str()); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 0, "IMAGE", "%s", ss.str().c_str()); } } } @@ -968,21 +968,21 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( if(pRegions[i].srcSubresource.layerCount == 0) { char const str[] = "vkCmdResolveImage: number of layers in source subresource is zero"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } if(pRegions[i].dstSubresource.layerCount == 0) { char const str[] = "vkCmdResolveImage: number of layers in destination subresource is zero"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } if ((pRegions[i].srcSubresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) || (pRegions[i].dstSubresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT)) { char const str[] = "vkCmdResolveImage: src and dest aspectMasks for each region must specify only VK_IMAGE_ASPECT_COLOR_BIT"; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } @@ -991,22 +991,22 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( (dstImageEntry != device_data->imageMap.end())) { if (srcImageEntry->second.format != dstImageEntry->second.format) { char const str[] = "vkCmdResolveImage called with unmatched source and dest formats."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str); } if (srcImageEntry->second.imageType != dstImageEntry->second.imageType) { char const str[] = "vkCmdResolveImage called with unmatched source and dest image types."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str); } if (srcImageEntry->second.samples == VK_SAMPLE_COUNT_1_BIT) { char const str[] = "vkCmdResolveImage called with source sample count less than 2."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str); } if (dstImageEntry->second.samples != VK_SAMPLE_COUNT_1_BIT) { char const str[] = "vkCmdResolveImage called with dest sample count greater than 1."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str); } } @@ -1036,7 +1036,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( if (pSubresource->aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) { std::stringstream ss; ss << "vkGetImageSubresourceLayout: For color formats, the aspectMask field of VkImageSubresource must be VK_IMAGE_ASPECT_COLOR."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } else if (vk_format_is_depth_or_stencil(format)) { @@ -1044,7 +1044,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( (pSubresource->aspectMask != VK_IMAGE_ASPECT_STENCIL_BIT)) { std::stringstream ss; ss << "vkGetImageSubresourceLayout: For depth/stencil formats, the aspectMask selects either the depth or stencil image aspectMask."; - skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t)image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp index 5ce7974f..0fb9e348 100644 --- a/layers/mem_tracker.cpp +++ b/layers/mem_tracker.cpp @@ -278,7 +278,7 @@ add_fence_info( // Validate that fence is in UNSIGNALED state VkFenceCreateInfo* pFenceCI = &(my_data->fenceMap[fence].createInfo); if (pFenceCI->flags & VK_FENCE_CREATE_SIGNALED_BIT) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", "Fence %#" PRIxLEAST64 " submitted in SIGNALED state. Fences must be reset before being submitted", (uint64_t) fence); } } else { @@ -372,7 +372,7 @@ validate_usage_flags( else correct_usage = ((actual & desired) != 0); if (!correct_usage) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, obj_type, obj_handle, 0, MEMTRACK_INVALID_USAGE_FLAG, "MEM", + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, obj_type, obj_handle, 0, MEMTRACK_INVALID_USAGE_FLAG, "MEM", "Invalid usage flag for %s %#" PRIxLEAST64 " used by %s. In this case, %s should have %s set during creation.", ty_str, obj_handle, func_name, ty_str, usage_str); } @@ -562,7 +562,7 @@ reportMemReferencesAndCleanUp( size_t objRefCount = pMemObjInfo->pObjBindings.size(); if ((pMemObjInfo->pCommandBufferBindings.size()) != 0) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) pMemObjInfo->mem, 0, MEMTRACK_FREED_MEM_REF, "MEM", + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) pMemObjInfo->mem, 0, MEMTRACK_FREED_MEM_REF, "MEM", "Attempting to free memory object %#" PRIxLEAST64 " which still contains " PRINTF_SIZE_T_SPECIFIER " references", (uint64_t) pMemObjInfo->mem, (cmdBufRefCount + objRefCount)); } @@ -570,7 +570,7 @@ reportMemReferencesAndCleanUp( if (cmdBufRefCount > 0 && pMemObjInfo->pCommandBufferBindings.size() > 0) { for (list::const_iterator it = pMemObjInfo->pCommandBufferBindings.begin(); it != pMemObjInfo->pCommandBufferBindings.end(); ++it) { // TODO : CommandBuffer should be source Obj here - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)(*it), 0, MEMTRACK_FREED_MEM_REF, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)(*it), 0, MEMTRACK_FREED_MEM_REF, "MEM", "Command Buffer %p still has a reference to mem obj %#" PRIxLEAST64, (*it), (uint64_t) pMemObjInfo->mem); } // Clear the list of hanging references @@ -579,7 +579,7 @@ reportMemReferencesAndCleanUp( if (objRefCount > 0 && pMemObjInfo->pObjBindings.size() > 0) { for (auto it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) { - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, it->type, it->handle, 0, MEMTRACK_FREED_MEM_REF, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, it->type, it->handle, 0, MEMTRACK_FREED_MEM_REF, "MEM", "VK Object %#" PRIxLEAST64 " still has a reference to mem obj %#" PRIxLEAST64, it->handle, (uint64_t) pMemObjInfo->mem); } // Clear the list of hanging references @@ -599,7 +599,7 @@ deleteMemObjInfo( if (item != my_data->memObjMap.end()) { my_data->memObjMap.erase(item); } else { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", "Request to delete memory object %#" PRIxLEAST64 " not present in memory Object Map", (uint64_t) mem); } return skipCall; @@ -621,7 +621,7 @@ checkCBCompleted( VkQueue queue = pCBInfo->lastSubmittedQueue; MT_QUEUE_INFO *pQueueInfo = &my_data->queueMap[queue]; if (pCBInfo->fenceId > pQueueInfo->lastRetiredId) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cb, 0, + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cb, 0, MEMTRACK_NONE, "MEM", "fence %#" PRIxLEAST64 " for CB %p has not been checked for completion", (uint64_t) pCBInfo->lastSubmittedFence, cb); *complete = VK_FALSE; @@ -643,7 +643,7 @@ freeMemObjInfo( MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(my_data, mem); if (pInfo) { if (pInfo->allocInfo.allocationSize == 0 && !internal) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", "Attempting to free memory associated with a Persistent Image, %#" PRIxLEAST64 ", " "this should not be explicitly freed\n", (uint64_t) mem); } else { @@ -729,7 +729,7 @@ clear_object_binding( } } if (VK_FALSE == clearSucceeded ) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", "While trying to clear mem binding for %s obj %#" PRIxLEAST64 ", unable to find that object referenced by mem obj %#" PRIxLEAST64, object_type_to_string(type), handle, (uint64_t) pMemObjInfo->mem); } @@ -757,12 +757,12 @@ set_mem_binding( VkBool32 skipCall = VK_FALSE; // Handle NULL case separately, just clear previous binding & decrement reference if (mem == VK_NULL_HANDLE) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, type, handle, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, type, handle, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", "In %s, attempting to Bind Obj(%#" PRIxLEAST64 ") to NULL", apiName, handle); } else { MT_OBJ_BINDING_INFO* pObjBindInfo = get_object_binding_info(my_data, handle, type); if (!pObjBindInfo) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", "In %s, attempting to update Binding of %s Obj(%#" PRIxLEAST64 ") that's not in global list()", object_type_to_string(type), apiName, handle); } else { @@ -772,7 +772,7 @@ set_mem_binding( // TODO : Need to track mem binding for obj and report conflict here MT_MEM_OBJ_INFO* pPrevBinding = get_mem_obj_info(my_data, pObjBindInfo->mem); if (pPrevBinding != NULL) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_REBIND_OBJECT, "MEM", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_REBIND_OBJECT, "MEM", "In %s, attempting to bind memory (%#" PRIxLEAST64 ") to object (%#" PRIxLEAST64 ") which has already been bound to mem object %#" PRIxLEAST64, apiName, (uint64_t) mem, handle, (uint64_t) pPrevBinding->mem); } @@ -821,7 +821,7 @@ set_sparse_mem_binding( } else { MT_OBJ_BINDING_INFO* pObjBindInfo = get_object_binding_info(my_data, handle, type); if (!pObjBindInfo) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", "In %s, attempting to update Binding of Obj(%#" PRIxLEAST64 ") that's not in global list()", apiName, handle); } // non-null case so should have real mem obj @@ -862,7 +862,7 @@ print_object_map_members( const char *objectStr) { for (auto const& element : objectName) { - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, objectType, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, objectType, 0, 0, MEMTRACK_NONE, "MEM", " %s Object list contains %s Object %#" PRIxLEAST64 " ", objectStr, objectStr, element.first); } } @@ -883,11 +883,11 @@ get_mem_binding_from_object( if (pObjBindInfo->mem) { *mem = pObjBindInfo->mem; } else { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", "Trying to get mem binding for object %#" PRIxLEAST64 " but object has no mem binding", handle); } } else { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_INVALID_OBJECT, "MEM", "Trying to get mem binding for object %#" PRIxLEAST64 " but no such object in %s list", handle, object_type_to_string(type)); } @@ -903,14 +903,14 @@ print_mem_list( MT_MEM_OBJ_INFO* pInfo = NULL; // Early out if info is not requested - if (!(my_data->report_data->active_flags & VK_DBG_REPORT_INFO_BIT)) { + if (!(my_data->report_data->active_flags & VK_DEBUG_REPORT_INFO_BIT)) { return; } // Just printing each msg individually for now, may want to package these into single large print - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", "Details of Memory Object list (of size " PRINTF_SIZE_T_SPECIFIER " elements)", my_data->memObjMap.size()); - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", "============================="); if (my_data->memObjMap.size() <= 0) @@ -919,36 +919,36 @@ print_mem_list( for (auto ii=my_data->memObjMap.begin(); ii!=my_data->memObjMap.end(); ++ii) { pInfo = &(*ii).second; - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", " ===MemObjInfo at %p===", (void*)pInfo); - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", " Mem object: %#" PRIxLEAST64, reinterpret_cast(pInfo->mem)); - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", " Ref Count: %u", pInfo->refCount); if (0 != pInfo->allocInfo.allocationSize) { string pAllocInfoMsg = vk_print_vkmemoryallocateinfo(&pInfo->allocInfo, "MEM(INFO): "); - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", " Mem Alloc info:\n%s", pAllocInfoMsg.c_str()); } else { - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", " Mem Alloc info is NULL (alloc done by vkCreateSwapchainKHR())"); } - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", " VK OBJECT Binding list of size " PRINTF_SIZE_T_SPECIFIER " elements:", pInfo->pObjBindings.size()); if (pInfo->pObjBindings.size() > 0) { for (list::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) { - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", " VK OBJECT %" PRIu64, it->handle); } } - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", " VK Command Buffer (CB) binding list of size " PRINTF_SIZE_T_SPECIFIER " elements", pInfo->pCommandBufferBindings.size()); if (pInfo->pCommandBufferBindings.size() > 0) { for (list::iterator it = pInfo->pCommandBufferBindings.begin(); it != pInfo->pCommandBufferBindings.end(); ++it) { - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", " VK CB %p", (*it)); } } @@ -963,13 +963,13 @@ printCBList( MT_CB_INFO* pCBInfo = NULL; // Early out if info is not requested - if (!(my_data->report_data->active_flags & VK_DBG_REPORT_INFO_BIT)) { + if (!(my_data->report_data->active_flags & VK_DEBUG_REPORT_INFO_BIT)) { return; } - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", "Details of CB list (of size " PRINTF_SIZE_T_SPECIFIER " elements)", my_data->cbMap.size()); - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", "=================="); if (my_data->cbMap.size() <= 0) @@ -978,7 +978,7 @@ printCBList( for (auto ii=my_data->cbMap.begin(); ii!=my_data->cbMap.end(); ++ii) { pCBInfo = &(*ii).second; - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", " CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %#" PRIxLEAST64, (void*)pCBInfo, (void*)pCBInfo->commandBuffer, pCBInfo->fenceId, (uint64_t) pCBInfo->lastSubmittedFence); @@ -986,7 +986,7 @@ printCBList( if (pCBInfo->pMemObjList.size() <= 0) continue; for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { - log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", + log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM", " Mem obj %" PRIu64, reinterpret_cast(*it)); } } @@ -1122,9 +1122,9 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( layer_data *my_device_data = get_my_data_ptr(key, layer_data_map); VkBool32 skipCall = VK_FALSE; loader_platform_thread_lock_mutex(&globalLock); - log_msg(my_device_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, (uint64_t)device, 0, MEMTRACK_NONE, "MEM", + log_msg(my_device_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, (uint64_t)device, 0, MEMTRACK_NONE, "MEM", "Printing List details prior to vkDestroyDevice()"); - log_msg(my_device_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, (uint64_t)device, 0, MEMTRACK_NONE, "MEM", + log_msg(my_device_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, (uint64_t)device, 0, MEMTRACK_NONE, "MEM", "================================================"); print_mem_list(my_device_data, device); printCBList(my_device_data, device); @@ -1135,7 +1135,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( for (auto ii=my_device_data->memObjMap.begin(); ii!=my_device_data->memObjMap.end(); ++ii) { pInfo = &(*ii).second; if (pInfo->allocInfo.allocationSize != 0) { - skipCall |= log_msg(my_device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM", + skipCall |= log_msg(my_device_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM", "Mem Object %" PRIu64 " has not been freed. You should clean up this memory by calling " "vkFreeMemory(%" PRIu64 ") prior to vkDestroyDevice().", reinterpret_cast(pInfo->mem), reinterpret_cast(pInfo->mem)); } @@ -1267,7 +1267,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( if (my_data->semaphoreMap.find(sem) != my_data->semaphoreMap.end()) { if (my_data->semaphoreMap[sem] != MEMTRACK_SEMAPHORE_STATE_SIGNALLED) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t) sem, + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t) sem, 0, MEMTRACK_NONE, "SEMAPHORE", "vkQueueSubmit: Semaphore must be in signaled state before passing to pWaitSemaphores"); } @@ -1279,7 +1279,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( if (my_data->semaphoreMap.find(sem) != my_data->semaphoreMap.end()) { if (my_data->semaphoreMap[sem] != MEMTRACK_SEMAPHORE_STATE_UNSET) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t) sem, + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t) sem, 0, MEMTRACK_NONE, "SEMAPHORE", "vkQueueSubmit: Semaphore must not be currently signaled or in a wait state"); } @@ -1358,7 +1358,7 @@ validateMemRange( VkBool32 skipCall = VK_FALSE; if (size == 0) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)mem, 0, + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)mem, 0, MEMTRACK_INVALID_MAP, "MEM", "VkMapMemory: Attempting to map memory range of size zero"); } @@ -1366,20 +1366,20 @@ validateMemRange( if (mem_element != my_data->memObjMap.end()) { // It is an application error to call VkMapMemory on an object that is already mapped if (mem_element->second.memRange.size != 0) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)mem, 0, + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)mem, 0, MEMTRACK_INVALID_MAP, "MEM", "VkMapMemory: Attempting to map memory on an already-mapped object %#" PRIxLEAST64, (uint64_t)mem); } // Validate that offset + size is within object's allocationSize if (size == VK_WHOLE_SIZE) { if (offset >= mem_element->second.allocInfo.allocationSize) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)mem, 0, + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)mem, 0, MEMTRACK_INVALID_MAP, "MEM", "Mapping Memory from %" PRIu64 " to %" PRIu64 " with total array size %" PRIu64, offset, mem_element->second.allocInfo.allocationSize, mem_element->second.allocInfo.allocationSize); } } else { if ((offset + size) > mem_element->second.allocInfo.allocationSize) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)mem, 0, + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)mem, 0, MEMTRACK_INVALID_MAP, "MEM", "Mapping Memory from %" PRIu64 " to %" PRIu64 " with total array size %" PRIu64, offset, size + offset, mem_element->second.allocInfo.allocationSize); } @@ -1412,7 +1412,7 @@ VkBool32 deleteMemRanges( auto mem_element = my_data->memObjMap.find(mem); if (mem_element != my_data->memObjMap.end()) { if (!mem_element->second.memRange.size) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)mem, 0, MEMTRACK_INVALID_MAP, "MEM", + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)mem, 0, MEMTRACK_INVALID_MAP, "MEM", "Unmapping Memory without memory being mapped: mem obj %#" PRIxLEAST64, (uint64_t)mem); } mem_element->second.memRange.size = 0; @@ -1463,7 +1463,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(my_data, mem); if (pMemObj && ((memProps.memoryTypes[pMemObj->allocInfo.memoryTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_STATE, "MEM", + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_STATE, "MEM", "Mapping Memory without VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT set: mem obj %#" PRIxLEAST64, (uint64_t) mem); } skipCall |= validateMemRange(my_data, mem, offset, size); @@ -1503,7 +1503,7 @@ validateMemoryIsMapped( if (mem_element != my_data->memObjMap.end()) { if (mem_element->second.memRange.offset > pMemRanges[i].offset || (mem_element->second.memRange.offset + mem_element->second.memRange.size) < (pMemRanges[i].offset + pMemRanges[i].size)) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)pMemRanges[i].memory, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)pMemRanges[i].memory, 0, MEMTRACK_INVALID_MAP, "MEM", "Memory must be mapped before it can be flushed or invalidated."); } } @@ -1527,13 +1527,13 @@ validateAndCopyNoncoherentMemoryToDriver( char* data = static_cast(mem_element->second.pData); for (auto j = 0; j < half_size; ++j) { if (data[j] != NoncoherentMemoryFillValue) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)pMemRanges[i].memory, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)pMemRanges[i].memory, 0, MEMTRACK_INVALID_MAP, "MEM", "Memory overflow was detected on mem obj %" PRIxLEAST64, (uint64_t)pMemRanges[i].memory); } } for (auto j = size + half_size; j < 2 * size; ++j) { if (data[j] != NoncoherentMemoryFillValue) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)pMemRanges[i].memory, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)pMemRanges[i].memory, 0, MEMTRACK_INVALID_MAP, "MEM", "Memory overflow was detected on mem obj %" PRIxLEAST64, (uint64_t)pMemRanges[i].memory); } } @@ -1778,7 +1778,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( if (fence_item != my_data->fenceMap.end()) { // Validate fences in SIGNALED state if (!(fence_item->second.createInfo.flags & VK_FENCE_CREATE_SIGNALED_BIT)) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", "Fence %#" PRIxLEAST64 " submitted to VkResetFences in UNSIGNALED STATE", (uint64_t) pFences[i]); } else { @@ -1807,11 +1807,11 @@ verifyFenceStatus( if (pFenceInfo->second.createInfo.flags & VK_FENCE_CREATE_SIGNALED_BIT) { // TODO: Possibly move this to a lower-level warning if we ever add, say, a VERBOSE warning option. There are too many // cases where ISVs want to be able to do this to make it a normal warning or perf-warning. - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", "%s specified fence %#" PRIxLEAST64 " already in SIGNALED state.", apiCall, (uint64_t) fence); } if (!pFenceInfo->second.queue) { // Checking status of unsubmitted fence - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", "%s called for fence %#" PRIxLEAST64 " which has not been submitted on a Queue.", apiCall, (uint64_t) fence); } } @@ -2033,7 +2033,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( commandBufferComplete = VK_FALSE; skipCall = checkCBCompleted(my_data, *it, &commandBufferComplete); if (VK_FALSE == commandBufferComplete) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)(*it), 0, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)(*it), 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Destroying Command Pool 0x%" PRIxLEAST64 " before " "its command buffer (0x%" PRIxLEAST64 ") has completed.", reinterpret_cast(commandPool), reinterpret_cast(*it)); @@ -2070,7 +2070,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( while (it != my_data->commandPoolMap[commandPool].pCommandBuffers.end()) { skipCall = checkCBCompleted(my_data, (*it), &commandBufferComplete); if (VK_FALSE == commandBufferComplete) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)(*it), 0, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)(*it), 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Resetting CB %p before it has completed. You must check CB " "flag before calling vkResetCommandBuffer().", (*it)); } else { @@ -2103,7 +2103,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( skipCall = checkCBCompleted(my_data, commandBuffer, &commandBufferComplete); if (VK_FALSE == commandBufferComplete) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Calling vkBeginCommandBuffer() on active CB %p before it has completed. " "You must check CB flag before this call.", commandBuffer); } @@ -2139,7 +2139,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( // Verify that CB is complete (not in-flight) skipCall = checkCBCompleted(my_data, commandBuffer, &commandBufferComplete); if (VK_FALSE == commandBufferComplete) { - skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)commandBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Resetting CB %p before it has completed. You must check CB " "flag before calling vkResetCommandBuffer().", commandBuffer); } @@ -2170,7 +2170,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( } else { "Attempt to bind Pipeline %p that doesn't exist!", (void*)pipeline); - layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str); + layerCbMsg(VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str); } #endif my_data->device_dispatch_table->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); @@ -2665,7 +2665,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( memcmp(&pInfo->images[0], pSwapchainImages, sizeof(pInfo->images[0]) * count)); if (mismatch) { - log_msg(my_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_SWAPCHAIN_KHR, (uint64_t) swapchain, 0, MEMTRACK_NONE, "SWAP_CHAIN", + log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_SWAPCHAIN_KHR, (uint64_t) swapchain, 0, MEMTRACK_NONE, "SWAP_CHAIN", "vkGetSwapchainInfoKHR(%" PRIu64 ", VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_KHR) returned mismatching data", reinterpret_cast(swapchain)); } } @@ -2688,7 +2688,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( loader_platform_thread_lock_mutex(&globalLock); if (my_data->semaphoreMap.find(semaphore) != my_data->semaphoreMap.end()) { if (my_data->semaphoreMap[semaphore] != MEMTRACK_SEMAPHORE_STATE_UNSET) { - skipCall = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t)semaphore, + skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t)semaphore, 0, MEMTRACK_NONE, "SEMAPHORE", "vkAcquireNextImageKHR: Semaphore must not be currently signaled or in a wait state"); } diff --git a/layers/object_track.h b/layers/object_track.h index e28dc80c..6bf39e60 100644 --- a/layers/object_track.h +++ b/layers/object_track.h @@ -314,7 +314,7 @@ addQueueInfo( g_pQueueInfo = pQueueInfo; } else { - log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast(queue), 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK", + log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast(queue), 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK", "ERROR: VK_ERROR_OUT_OF_HOST_MEMORY -- could not allocate memory for Queue Information"); } } @@ -363,10 +363,10 @@ validateQueueFlags( } if (pQueueInfo != NULL) { if ((queueInfo != NULL) && (queueInfo[pQueueInfo->queueNodeIndex].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) == 0) { - log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast(queue), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", + log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast(queue), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", "Attempting %s on a non-memory-management capable queue -- VK_QUEUE_SPARSE_BINDING_BIT not set", function); } else { - log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast(queue), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", + log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast(queue), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", "Attempting %s on a possibly non-memory-management capable queue -- VK_QUEUE_SPARSE_BINDING_BIT not known", function); } } @@ -484,7 +484,7 @@ static VkBool32 validate_image(VkQueue dispatchable_object, VkImage object) { if ((VkImageMap.find(reinterpret_cast(object)) == VkImageMap.end()) && (swapchainImageMap.find(reinterpret_cast(object)) == swapchainImageMap.end())) { - return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", + return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", "Invalid VkImage Object %" PRIu64, reinterpret_cast(object)); } return VK_FALSE; @@ -494,7 +494,7 @@ static VkBool32 validate_image(VkCommandBuffer dispatchable_object, VkImage obje { if ((VkImageMap.find(reinterpret_cast(object)) == VkImageMap.end()) && (swapchainImageMap.find(reinterpret_cast(object)) == swapchainImageMap.end())) { - return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", + return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", "Invalid VkImage Object %" PRIu64, reinterpret_cast(object)); } return VK_FALSE; @@ -503,7 +503,7 @@ static VkBool32 validate_image(VkCommandBuffer dispatchable_object, VkImage obje static VkBool32 validate_command_buffer(VkQueue dispatchable_object, VkCommandBuffer object) { if (VkCommandBufferMap.find(reinterpret_cast(object)) == VkCommandBufferMap.end()) { - return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", + return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", "Invalid VkCommandBuffer Object %" PRIu64, reinterpret_cast(object)); } return VK_FALSE; @@ -512,7 +512,7 @@ static VkBool32 validate_command_buffer(VkQueue dispatchable_object, VkCommandBu static VkBool32 validate_descriptor_set(VkCommandBuffer dispatchable_object, VkDescriptorSet object) { if (VkDescriptorSetMap.find(reinterpret_cast(object)) == VkDescriptorSetMap.end()) { - return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", + return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", "Invalid VkDescriptorSet Object %" PRIu64, reinterpret_cast(object)); } return VK_FALSE; @@ -521,7 +521,7 @@ static VkBool32 validate_descriptor_set(VkCommandBuffer dispatchable_object, VkD static VkBool32 validate_buffer(VkQueue dispatchable_object, VkBuffer object) { if (VkBufferMap.find(reinterpret_cast(object)) != VkBufferMap.end()) { - return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", + return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", "Invalid VkBuffer Object %" PRIu64, reinterpret_cast(object)); } return VK_FALSE; @@ -537,7 +537,7 @@ static VkBool32 set_status(VkQueue dispatchable_object, VkFence object, VkDbgObj } else { // If we do not find it print an error - skipCall |= log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK", + skipCall |= log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK", "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type", reinterpret_cast(object), string_VkDbgObjectType(objType)); } @@ -548,7 +548,7 @@ static VkBool32 set_status(VkQueue dispatchable_object, VkFence object, VkDbgObj static VkBool32 validate_semaphore(VkQueue dispatchable_object, VkSemaphore object) { if (VkSemaphoreMap.find(reinterpret_cast(object)) == VkSemaphoreMap.end()) { - return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", + return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", "Invalid VkSemaphore Object %" PRIu64, reinterpret_cast(object)); } return VK_FALSE; @@ -557,7 +557,7 @@ static VkBool32 validate_semaphore(VkQueue dispatchable_object, VkSemaphore obje static VkBool32 validate_command_buffer(VkDevice dispatchable_object, VkCommandBuffer object) { if (VkCommandBufferMap.find(reinterpret_cast(object)) == VkCommandBufferMap.end()) { - return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", + return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK", "Invalid VkCommandBuffer Object %" PRIu64, reinterpret_cast(object)); } return VK_FALSE; @@ -565,7 +565,7 @@ static VkBool32 validate_command_buffer(VkDevice dispatchable_object, VkCommandB static void create_physical_device(VkInstance dispatchable_object, VkPhysicalDevice vkObj, VkDbgObjectType objType) { - log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast(vkObj), 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT, objType, reinterpret_cast(vkObj), 0, OBJTRACK_NONE, "OBJTRACK", "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType), reinterpret_cast(vkObj)); @@ -591,7 +591,7 @@ static void destroy_surface_khr(VkInstance instance, VkSurfaceKHR surface) static void alloc_command_buffer(VkDevice device, VkCommandPool commandPool, VkCommandBuffer vkObj, VkDbgObjectType objType) { - log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast(vkObj), 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(device), VK_DEBUG_REPORT_INFO_BIT, objType, reinterpret_cast(vkObj), 0, OBJTRACK_NONE, "OBJTRACK", "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType), reinterpret_cast(vkObj)); @@ -613,7 +613,7 @@ static void free_command_buffer(VkDevice device, VkCommandPool commandPool, VkCo OBJTRACK_NODE* pNode = VkCommandBufferMap[(uint64_t)commandBuffer]; if (pNode->parentObj != reinterpret_cast(commandPool)) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, pNode->objType, object_handle, 0, OBJTRACK_COMMAND_POOL_MISMATCH, "OBJTRACK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, pNode->objType, object_handle, 0, OBJTRACK_COMMAND_POOL_MISMATCH, "OBJTRACK", "FreeCommandBuffers is attempting to free Command Buffer 0x%" PRIxLEAST64 " belonging to Command Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").", reinterpret_cast(commandBuffer), pNode->parentObj, reinterpret_cast(commandPool)); } else { @@ -623,7 +623,7 @@ static void free_command_buffer(VkDevice device, VkCommandPool commandPool, VkCo numTotalObjs--; assert(numObjs[objIndex] > 0); numObjs[objIndex]--; - log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, pNode->objType, object_handle, 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(device), VK_DEBUG_REPORT_INFO_BIT, pNode->objType, object_handle, 0, OBJTRACK_NONE, "OBJTRACK", "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", string_VkDbgObjectType(pNode->objType), reinterpret_cast(commandBuffer), numTotalObjs, numObjs[objIndex], string_VkDbgObjectType(pNode->objType)); @@ -631,7 +631,7 @@ static void free_command_buffer(VkDevice device, VkCommandPool commandPool, VkCo VkCommandBufferMap.erase(object_handle); } } else { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object_handle, 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object_handle, 0, OBJTRACK_NONE, "OBJTRACK", "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", object_handle); } @@ -639,7 +639,7 @@ static void free_command_buffer(VkDevice device, VkCommandPool commandPool, VkCo static void alloc_descriptor_set(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSet vkObj, VkDbgObjectType objType) { - log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast(vkObj), 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(device), VK_DEBUG_REPORT_INFO_BIT, objType, reinterpret_cast(vkObj), 0, OBJTRACK_NONE, "OBJTRACK", "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType), reinterpret_cast(vkObj)); @@ -661,7 +661,7 @@ static void free_descriptor_set(VkDevice device, VkDescriptorPool descriptorPool OBJTRACK_NODE* pNode = VkDescriptorSetMap[(uint64_t)descriptorSet]; if (pNode->parentObj != reinterpret_cast(descriptorPool)) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, pNode->objType, object_handle, 0, OBJTRACK_DESCRIPTOR_POOL_MISMATCH, "OBJTRACK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, pNode->objType, object_handle, 0, OBJTRACK_DESCRIPTOR_POOL_MISMATCH, "OBJTRACK", "FreeDescriptorSets is attempting to free descriptorSet 0x%" PRIxLEAST64 " belonging to Descriptor Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").", reinterpret_cast(descriptorSet), pNode->parentObj, reinterpret_cast(descriptorPool)); } else { @@ -670,7 +670,7 @@ static void free_descriptor_set(VkDevice device, VkDescriptorPool descriptorPool numTotalObjs--; assert(numObjs[objIndex] > 0); numObjs[objIndex]--; - log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, pNode->objType, object_handle, 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(device), VK_DEBUG_REPORT_INFO_BIT, pNode->objType, object_handle, 0, OBJTRACK_NONE, "OBJTRACK", "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", string_VkDbgObjectType(pNode->objType), reinterpret_cast(descriptorSet), numTotalObjs, numObjs[objIndex], string_VkDbgObjectType(pNode->objType)); @@ -678,7 +678,7 @@ static void free_descriptor_set(VkDevice device, VkDescriptorPool descriptorPool VkDescriptorSetMap.erase(object_handle); } } else { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object_handle, 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object_handle, 0, OBJTRACK_NONE, "OBJTRACK", "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", object_handle); } @@ -686,7 +686,7 @@ static void free_descriptor_set(VkDevice device, VkDescriptorPool descriptorPool static void create_swapchain_khr(VkDevice dispatchable_object, VkSwapchainKHR vkObj, VkDbgObjectType objType) { - log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, (uint64_t) vkObj, 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT, objType, (uint64_t) vkObj, 0, OBJTRACK_NONE, "OBJTRACK", "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType), reinterpret_cast(vkObj)); @@ -701,7 +701,7 @@ static void create_swapchain_khr(VkDevice dispatchable_object, VkSwapchainKHR vk } static void create_queue(VkDevice dispatchable_object, VkQueue vkObj, VkDbgObjectType objType) { - log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast(vkObj), 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT, objType, reinterpret_cast(vkObj), 0, OBJTRACK_NONE, "OBJTRACK", "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType), reinterpret_cast(vkObj)); @@ -716,7 +716,7 @@ static void create_queue(VkDevice dispatchable_object, VkQueue vkObj, VkDbgObjec } static void create_swapchain_image_obj(VkDevice dispatchable_object, VkImage vkObj, VkSwapchainKHR swapchain) { - log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t) vkObj, 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t) vkObj, 0, OBJTRACK_NONE, "OBJTRACK", "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, "SwapchainImage", reinterpret_cast(vkObj)); @@ -737,14 +737,14 @@ static void destroy_swapchain(VkDevice dispatchable_object, VkSwapchainKHR objec numTotalObjs--; assert(numObjs[objIndex] > 0); numObjs[objIndex]--; - log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT, pNode->objType, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK", "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", string_VkDbgObjectType(pNode->objType), (uint64_t) object, numTotalObjs, numObjs[objIndex], string_VkDbgObjectType(pNode->objType)); delete pNode; VkSwapchainKHRMap.erase(reinterpret_cast(object)); } else { - log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK", "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", reinterpret_cast(object)); } diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp index c94ce8f5..db66d693 100644 --- a/layers/param_checker.cpp +++ b/layers/param_checker.cpp @@ -1789,7 +1789,7 @@ bool PostEnumeratePhysicalDevices( if(result < VK_SUCCESS) { std::string reason = "vkEnumeratePhysicalDevices parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mid(instance), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -1838,7 +1838,7 @@ bool PostGetPhysicalDeviceFormatProperties( if(format < VK_FORMAT_BEGIN_RANGE || format > VK_FORMAT_END_RANGE) { - log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkGetPhysicalDeviceFormatProperties parameter, VkFormat format, is an unrecognized enumerator"); return false; } @@ -1874,7 +1874,7 @@ bool PostGetPhysicalDeviceImageFormatProperties( if(format < VK_FORMAT_BEGIN_RANGE || format > VK_FORMAT_END_RANGE) { - log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkGetPhysicalDeviceImageFormatProperties parameter, VkFormat format, is an unrecognized enumerator"); return false; } @@ -1882,7 +1882,7 @@ bool PostGetPhysicalDeviceImageFormatProperties( if(type < VK_IMAGE_TYPE_BEGIN_RANGE || type > VK_IMAGE_TYPE_END_RANGE) { - log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkGetPhysicalDeviceImageFormatProperties parameter, VkImageType type, is an unrecognized enumerator"); return false; } @@ -1890,7 +1890,7 @@ bool PostGetPhysicalDeviceImageFormatProperties( if(tiling < VK_IMAGE_TILING_BEGIN_RANGE || tiling > VK_IMAGE_TILING_END_RANGE) { - log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkGetPhysicalDeviceImageFormatProperties parameter, VkImageTiling tiling, is an unrecognized enumerator"); return false; } @@ -1903,7 +1903,7 @@ bool PostGetPhysicalDeviceImageFormatProperties( if(result < VK_SUCCESS) { std::string reason = "vkGetPhysicalDeviceImageFormatProperties parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -1936,7 +1936,7 @@ bool PostGetPhysicalDeviceProperties( if(pProperties->deviceType < VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE || pProperties->deviceType > VK_PHYSICAL_DEVICE_TYPE_END_RANGE) { - log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkGetPhysicalDeviceProperties parameter, VkPhysicalDeviceType pProperties->deviceType, is an unrecognized enumerator"); return false; } @@ -2075,7 +2075,7 @@ bool PreQueueSubmit( const VkSubmitInfo* submit) { if(submit->sType != VK_STRUCTURE_TYPE_SUBMIT_INFO) { - log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkQueueSubmit parameter, VkStructureType pSubmits->sType, is an invalid enumerator"); return false; } @@ -2099,7 +2099,7 @@ bool PostQueueSubmit( if(result < VK_SUCCESS) { std::string reason = "vkQueueSubmit parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2131,7 +2131,7 @@ bool PostQueueWaitIdle( if(result < VK_SUCCESS) { std::string reason = "vkQueueWaitIdle parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2156,7 +2156,7 @@ bool PostDeviceWaitIdle( if(result < VK_SUCCESS) { std::string reason = "vkDeviceWaitIdle parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2181,7 +2181,7 @@ bool PreAllocateMemory( { if(pAllocateInfo->sType != VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkAllocateMemory parameter, VkStructureType pAllocateInfo->sType, is an invalid enumerator"); return false; } @@ -2203,7 +2203,7 @@ bool PostAllocateMemory( if(result < VK_SUCCESS) { std::string reason = "vkAllocateMemory parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2246,7 +2246,7 @@ bool PostMapMemory( if(result < VK_SUCCESS) { std::string reason = "vkMapMemory parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2276,7 +2276,7 @@ bool PreFlushMappedMemoryRanges( { if(pMemoryRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkFlushMappedMemoryRanges parameter, VkStructureType pMemoryRanges->sType, is an invalid enumerator"); return false; } @@ -2295,7 +2295,7 @@ bool PostFlushMappedMemoryRanges( if(result < VK_SUCCESS) { std::string reason = "vkFlushMappedMemoryRanges parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2324,7 +2324,7 @@ bool PreInvalidateMappedMemoryRanges( { if(pMemoryRanges->sType != VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkInvalidateMappedMemoryRanges parameter, VkStructureType pMemoryRanges->sType, is an invalid enumerator"); return false; } @@ -2343,7 +2343,7 @@ bool PostInvalidateMappedMemoryRanges( if(result < VK_SUCCESS) { std::string reason = "vkInvalidateMappedMemoryRanges parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2402,7 +2402,7 @@ bool PostBindBufferMemory( if(result < VK_SUCCESS) { std::string reason = "vkBindBufferMemory parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2436,7 +2436,7 @@ bool PostBindImageMemory( if(result < VK_SUCCESS) { std::string reason = "vkBindImageMemory parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2521,7 +2521,7 @@ bool PostGetImageSparseMemoryRequirements( if ((pSparseMemoryRequirements->formatProperties.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkGetImageSparseMemoryRequirements parameter, VkImageAspect pSparseMemoryRequirements->formatProperties.aspectMask, is an unrecognized enumerator"); return false; } @@ -2555,7 +2555,7 @@ bool PostGetPhysicalDeviceSparseImageFormatProperties( if(format < VK_FORMAT_BEGIN_RANGE || format > VK_FORMAT_END_RANGE) { - log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkGetPhysicalDeviceSparseImageFormatProperties parameter, VkFormat format, is an unrecognized enumerator"); return false; } @@ -2563,7 +2563,7 @@ bool PostGetPhysicalDeviceSparseImageFormatProperties( if(type < VK_IMAGE_TYPE_BEGIN_RANGE || type > VK_IMAGE_TYPE_END_RANGE) { - log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkGetPhysicalDeviceSparseImageFormatProperties parameter, VkImageType type, is an unrecognized enumerator"); return false; } @@ -2573,7 +2573,7 @@ bool PostGetPhysicalDeviceSparseImageFormatProperties( if(tiling < VK_IMAGE_TILING_BEGIN_RANGE || tiling > VK_IMAGE_TILING_END_RANGE) { - log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkGetPhysicalDeviceSparseImageFormatProperties parameter, VkImageTiling tiling, is an unrecognized enumerator"); return false; } @@ -2587,7 +2587,7 @@ bool PostGetPhysicalDeviceSparseImageFormatProperties( if ((pProperties->aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) { - log_msg(mdd(physicalDevice), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(physicalDevice), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkGetPhysicalDeviceSparseImageFormatProperties parameter, VkImageAspect pProperties->aspectMask, is an unrecognized enumerator"); return false; } @@ -2636,7 +2636,7 @@ bool PostQueueBindSparse( if(result < VK_SUCCESS) { std::string reason = "vkQueueBindSparse parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(queue), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2666,7 +2666,7 @@ bool PreCreateFence( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_FENCE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateFence parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } @@ -2688,7 +2688,7 @@ bool PostCreateFence( if(result < VK_SUCCESS) { std::string reason = "vkCreateFence parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2731,7 +2731,7 @@ bool PostResetFences( if(result < VK_SUCCESS) { std::string reason = "vkResetFences parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2762,7 +2762,7 @@ bool PostGetFenceStatus( if(result < VK_SUCCESS) { std::string reason = "vkGetFenceStatus parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2805,7 +2805,7 @@ bool PostWaitForFences( if(result < VK_SUCCESS) { std::string reason = "vkWaitForFences parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2836,7 +2836,7 @@ bool PreCreateSemaphore( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateSemaphore parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } @@ -2858,7 +2858,7 @@ bool PostCreateSemaphore( if(result < VK_SUCCESS) { std::string reason = "vkCreateSemaphore parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2888,7 +2888,7 @@ bool PreCreateEvent( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_EVENT_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateEvent parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } @@ -2910,7 +2910,7 @@ bool PostCreateEvent( if(result < VK_SUCCESS) { std::string reason = "vkCreateEvent parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2942,7 +2942,7 @@ bool PostGetEventStatus( if(result < VK_SUCCESS) { std::string reason = "vkGetEventStatus parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2970,7 +2970,7 @@ bool PostSetEvent( if(result < VK_SUCCESS) { std::string reason = "vkSetEvent parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -2998,7 +2998,7 @@ bool PostResetEvent( if(result < VK_SUCCESS) { std::string reason = "vkResetEvent parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3024,14 +3024,14 @@ bool PreCreateQueryPool( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateQueryPool parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } if(pCreateInfo->queryType < VK_QUERY_TYPE_BEGIN_RANGE || pCreateInfo->queryType > VK_QUERY_TYPE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateQueryPool parameter, VkQueryType pCreateInfo->queryType, is an unrecognized enumerator"); return false; } @@ -3053,7 +3053,7 @@ bool PostCreateQueryPool( if(result < VK_SUCCESS) { std::string reason = "vkCreateQueryPool parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3098,7 +3098,7 @@ bool PostGetQueryPoolResults( if(result < VK_SUCCESS) { std::string reason = "vkGetQueryPoolResults parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3130,14 +3130,14 @@ bool PreCreateBuffer( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateBuffer parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } if(pCreateInfo->sharingMode < VK_SHARING_MODE_BEGIN_RANGE || pCreateInfo->sharingMode > VK_SHARING_MODE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateBuffer parameter, VkSharingMode pCreateInfo->sharingMode, is an unrecognized enumerator"); return false; } @@ -3162,7 +3162,7 @@ bool PostCreateBuffer( if(result < VK_SUCCESS) { std::string reason = "vkCreateBuffer parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3192,14 +3192,14 @@ bool PreCreateBufferView( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateBufferView parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE || pCreateInfo->format > VK_FORMAT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateBufferView parameter, VkFormat pCreateInfo->format, is an unrecognized enumerator"); return false; } @@ -3221,7 +3221,7 @@ bool PostCreateBufferView( if(result < VK_SUCCESS) { std::string reason = "vkCreateBufferView parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3251,35 +3251,35 @@ bool PreCreateImage( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImage parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } if(pCreateInfo->imageType < VK_IMAGE_TYPE_BEGIN_RANGE || pCreateInfo->imageType > VK_IMAGE_TYPE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImage parameter, VkImageType pCreateInfo->imageType, is an unrecognized enumerator"); return false; } if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE || pCreateInfo->format > VK_FORMAT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImage parameter, VkFormat pCreateInfo->format, is an unrecognized enumerator"); return false; } if(pCreateInfo->tiling < VK_IMAGE_TILING_BEGIN_RANGE || pCreateInfo->tiling > VK_IMAGE_TILING_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImage parameter, VkImageTiling pCreateInfo->tiling, is an unrecognized enumerator"); return false; } if(pCreateInfo->sharingMode < VK_SHARING_MODE_BEGIN_RANGE || pCreateInfo->sharingMode > VK_SHARING_MODE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImage parameter, VkSharingMode pCreateInfo->sharingMode, is an unrecognized enumerator"); return false; } @@ -3304,7 +3304,7 @@ bool PostCreateImage( if(result < VK_SUCCESS) { std::string reason = "vkCreateImage parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3335,7 +3335,7 @@ bool PreGetImageSubresourceLayout( if ((pSubresource->aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkGetImageSubresourceLayout parameter, VkImageAspect pSubresource->aspectMask, is an unrecognized enumerator"); return false; } @@ -3379,49 +3379,49 @@ bool PreCreateImageView( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImageView parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } if(pCreateInfo->viewType < VK_IMAGE_VIEW_TYPE_BEGIN_RANGE || pCreateInfo->viewType > VK_IMAGE_VIEW_TYPE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImageView parameter, VkImageViewType pCreateInfo->viewType, is an unrecognized enumerator"); return false; } if(pCreateInfo->format < VK_FORMAT_BEGIN_RANGE || pCreateInfo->format > VK_FORMAT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImageView parameter, VkFormat pCreateInfo->format, is an unrecognized enumerator"); return false; } if(pCreateInfo->components.r < VK_COMPONENT_SWIZZLE_BEGIN_RANGE || pCreateInfo->components.r > VK_COMPONENT_SWIZZLE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->components.r, is an unrecognized enumerator"); return false; } if(pCreateInfo->components.g < VK_COMPONENT_SWIZZLE_BEGIN_RANGE || pCreateInfo->components.g > VK_COMPONENT_SWIZZLE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->components.g, is an unrecognized enumerator"); return false; } if(pCreateInfo->components.b < VK_COMPONENT_SWIZZLE_BEGIN_RANGE || pCreateInfo->components.b > VK_COMPONENT_SWIZZLE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->components.b, is an unrecognized enumerator"); return false; } if(pCreateInfo->components.a < VK_COMPONENT_SWIZZLE_BEGIN_RANGE || pCreateInfo->components.a > VK_COMPONENT_SWIZZLE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateImageView parameter, VkComponentSwizzle pCreateInfo->components.a, is an unrecognized enumerator"); return false; } @@ -3443,7 +3443,7 @@ bool PostCreateImageView( if(result < VK_SUCCESS) { std::string reason = "vkCreateImageView parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3471,17 +3471,17 @@ bool PreCreateShaderModule( { if(pCreateInfo) { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateShaderModule parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } if(!pCreateInfo->pCode) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateShaderModule paramter, void* pCreateInfo->pCode, is null"); return false; } } else { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateShaderModule parameter, VkShaderModuleCreateInfo pCreateInfo, is null"); return false; } @@ -3496,7 +3496,7 @@ bool PostCreateShaderModule( { if(result < VK_SUCCESS) { std::string reason = "vkCreateShaderModule parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3523,7 +3523,7 @@ bool PreCreatePipelineCache( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreatePipelineCache parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } @@ -3548,7 +3548,7 @@ bool PostCreatePipelineCache( if(result < VK_SUCCESS) { std::string reason = "vkCreatePipelineCache parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3590,7 +3590,7 @@ bool PostGetPipelineCacheData( if(result < VK_SUCCESS) { std::string reason = "vkGetPipelineCacheData parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3633,7 +3633,7 @@ bool PostMergePipelineCaches( if(result < VK_SUCCESS) { std::string reason = "vkMergePipelineCaches parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3663,7 +3663,7 @@ bool PreCreateGraphicsPipelines( { if(pCreateInfos->sType != VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->sType, is an invalid enumerator"); return false; } @@ -3671,7 +3671,7 @@ bool PreCreateGraphicsPipelines( { if(pCreateInfos->pStages->sType != VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pStages->sType, is an invalid enumerator"); return false; } @@ -3689,7 +3689,7 @@ bool PreCreateGraphicsPipelines( { if(pCreateInfos->pVertexInputState->sType != VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pVertexInputState->sType, is an invalid enumerator"); return false; } @@ -3698,7 +3698,7 @@ bool PreCreateGraphicsPipelines( if(pCreateInfos->pVertexInputState->pVertexBindingDescriptions->inputRate < VK_VERTEX_INPUT_RATE_BEGIN_RANGE || pCreateInfos->pVertexInputState->pVertexBindingDescriptions->inputRate > VK_VERTEX_INPUT_RATE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkVertexInputRate pCreateInfos->pVertexInputState->pVertexBindingDescriptions->inputRate, is an unrecognized enumerator"); return false; } @@ -3708,7 +3708,7 @@ bool PreCreateGraphicsPipelines( if(pCreateInfos->pVertexInputState->pVertexAttributeDescriptions->format < VK_FORMAT_BEGIN_RANGE || pCreateInfos->pVertexInputState->pVertexAttributeDescriptions->format > VK_FORMAT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkFormat pCreateInfos->pVertexInputState->pVertexAttributeDescriptions->format, is an unrecognized enumerator"); return false; } @@ -3718,14 +3718,14 @@ bool PreCreateGraphicsPipelines( { if(pCreateInfos->pInputAssemblyState->sType != VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pInputAssemblyState->sType, is an invalid enumerator"); return false; } if(pCreateInfos->pInputAssemblyState->topology < VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE || pCreateInfos->pInputAssemblyState->topology > VK_PRIMITIVE_TOPOLOGY_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkPrimitiveTopology pCreateInfos->pInputAssemblyState->topology, is an unrecognized enumerator"); return false; } @@ -3734,7 +3734,7 @@ bool PreCreateGraphicsPipelines( { if(pCreateInfos->pTessellationState->sType != VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pTessellationState->sType, is an invalid enumerator"); return false; } @@ -3743,7 +3743,7 @@ bool PreCreateGraphicsPipelines( { if(pCreateInfos->pViewportState->sType != VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pViewportState->sType, is an invalid enumerator"); return false; } @@ -3752,27 +3752,27 @@ bool PreCreateGraphicsPipelines( { if(pCreateInfos->pRasterizationState->sType != VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pRasterizationState->sType, is an invalid enumerator"); return false; } if(pCreateInfos->pRasterizationState->polygonMode < VK_POLYGON_MODE_BEGIN_RANGE || pCreateInfos->pRasterizationState->polygonMode > VK_POLYGON_MODE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkPolygonMode pCreateInfos->pRasterizationState->polygonMode, is an unrecognized enumerator"); return false; } if(pCreateInfos->pRasterizationState->cullMode & ~VK_CULL_MODE_FRONT_AND_BACK) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkCullMode pCreateInfos->pRasterizationState->cullMode, is an unrecognized enumerator"); return false; } if(pCreateInfos->pRasterizationState->frontFace < VK_FRONT_FACE_BEGIN_RANGE || pCreateInfos->pRasterizationState->frontFace > VK_FRONT_FACE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkFrontFace pCreateInfos->pRasterizationState->frontFace, is an unrecognized enumerator"); return false; } @@ -3781,7 +3781,7 @@ bool PreCreateGraphicsPipelines( { if(pCreateInfos->pMultisampleState->sType != VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pMultisampleState->sType, is an invalid enumerator"); return false; } @@ -3790,70 +3790,70 @@ bool PreCreateGraphicsPipelines( { if(pCreateInfos->pDepthStencilState->sType != VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pDepthStencilState->sType, is an invalid enumerator"); return false; } if(pCreateInfos->pDepthStencilState->depthCompareOp < VK_COMPARE_OP_BEGIN_RANGE || pCreateInfos->pDepthStencilState->depthCompareOp > VK_COMPARE_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkCompareOp pCreateInfos->pDepthStencilState->depthCompareOp, is an unrecognized enumerator"); return false; } if(pCreateInfos->pDepthStencilState->front.failOp < VK_STENCIL_OP_BEGIN_RANGE || pCreateInfos->pDepthStencilState->front.failOp > VK_STENCIL_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.failOp, is an unrecognized enumerator"); return false; } if(pCreateInfos->pDepthStencilState->front.passOp < VK_STENCIL_OP_BEGIN_RANGE || pCreateInfos->pDepthStencilState->front.passOp > VK_STENCIL_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.passOp, is an unrecognized enumerator"); return false; } if(pCreateInfos->pDepthStencilState->front.depthFailOp < VK_STENCIL_OP_BEGIN_RANGE || pCreateInfos->pDepthStencilState->front.depthFailOp > VK_STENCIL_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->front.depthFailOp, is an unrecognized enumerator"); return false; } if(pCreateInfos->pDepthStencilState->front.compareOp < VK_COMPARE_OP_BEGIN_RANGE || pCreateInfos->pDepthStencilState->front.compareOp > VK_COMPARE_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkCompareOp pCreateInfos->pDepthStencilState->front.compareOp, is an unrecognized enumerator"); return false; } if(pCreateInfos->pDepthStencilState->back.failOp < VK_STENCIL_OP_BEGIN_RANGE || pCreateInfos->pDepthStencilState->back.failOp > VK_STENCIL_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.failOp, is an unrecognized enumerator"); return false; } if(pCreateInfos->pDepthStencilState->back.passOp < VK_STENCIL_OP_BEGIN_RANGE || pCreateInfos->pDepthStencilState->back.passOp > VK_STENCIL_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.passOp, is an unrecognized enumerator"); return false; } if(pCreateInfos->pDepthStencilState->back.depthFailOp < VK_STENCIL_OP_BEGIN_RANGE || pCreateInfos->pDepthStencilState->back.depthFailOp > VK_STENCIL_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStencilOp pCreateInfos->pDepthStencilState->back.depthFailOp, is an unrecognized enumerator"); return false; } if(pCreateInfos->pDepthStencilState->back.compareOp < VK_COMPARE_OP_BEGIN_RANGE || pCreateInfos->pDepthStencilState->back.compareOp > VK_COMPARE_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkCompareOp pCreateInfos->pDepthStencilState->back.compareOp, is an unrecognized enumerator"); return false; } @@ -3862,7 +3862,7 @@ bool PreCreateGraphicsPipelines( { if(pCreateInfos->pColorBlendState->sType != VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pColorBlendState->sType, is an invalid enumerator"); return false; } @@ -3870,7 +3870,7 @@ bool PreCreateGraphicsPipelines( pCreateInfos->pColorBlendState->logicOp < VK_LOGIC_OP_BEGIN_RANGE || pCreateInfos->pColorBlendState->logicOp > VK_LOGIC_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkLogicOp pCreateInfos->pColorBlendState->logicOp, is an unrecognized enumerator"); return false; } @@ -3879,42 +3879,42 @@ bool PreCreateGraphicsPipelines( if(pCreateInfos->pColorBlendState->pAttachments->srcColorBlendFactor < VK_BLEND_FACTOR_BEGIN_RANGE || pCreateInfos->pColorBlendState->pAttachments->srcColorBlendFactor > VK_BLEND_FACTOR_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->srcColorBlendFactor, is an unrecognized enumerator"); return false; } if(pCreateInfos->pColorBlendState->pAttachments->dstColorBlendFactor < VK_BLEND_FACTOR_BEGIN_RANGE || pCreateInfos->pColorBlendState->pAttachments->dstColorBlendFactor > VK_BLEND_FACTOR_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->dstColorBlendFactor, is an unrecognized enumerator"); return false; } if(pCreateInfos->pColorBlendState->pAttachments->colorBlendOp < VK_BLEND_OP_BEGIN_RANGE || pCreateInfos->pColorBlendState->pAttachments->colorBlendOp > VK_BLEND_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkBlendOp pCreateInfos->pColorBlendState->pAttachments->colorBlendOp, is an unrecognized enumerator"); return false; } if(pCreateInfos->pColorBlendState->pAttachments->srcAlphaBlendFactor < VK_BLEND_FACTOR_BEGIN_RANGE || pCreateInfos->pColorBlendState->pAttachments->srcAlphaBlendFactor > VK_BLEND_FACTOR_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->srcAlphaBlendFactor, is an unrecognized enumerator"); return false; } if(pCreateInfos->pColorBlendState->pAttachments->dstAlphaBlendFactor < VK_BLEND_FACTOR_BEGIN_RANGE || pCreateInfos->pColorBlendState->pAttachments->dstAlphaBlendFactor > VK_BLEND_FACTOR_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkBlendFactor pCreateInfos->pColorBlendState->pAttachments->dstAlphaBlendFactor, is an unrecognized enumerator"); return false; } if(pCreateInfos->pColorBlendState->pAttachments->alphaBlendOp < VK_BLEND_OP_BEGIN_RANGE || pCreateInfos->pColorBlendState->pAttachments->alphaBlendOp > VK_BLEND_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkBlendOp pCreateInfos->pColorBlendState->pAttachments->alphaBlendOp, is an unrecognized enumerator"); return false; } @@ -3922,7 +3922,7 @@ bool PreCreateGraphicsPipelines( } if(pCreateInfos->renderPass == VK_NULL_HANDLE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateGraphicsPipelines parameter, VkRenderPass pCreateInfos->renderPass, is null pointer"); } } @@ -3947,7 +3947,7 @@ bool PostCreateGraphicsPipelines( if(result < VK_SUCCESS) { std::string reason = "vkCreateGraphicsPipelines parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -3979,13 +3979,13 @@ bool PreCreateComputePipelines( { if(pCreateInfos->sType != VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateComputePipelines parameter, VkStructureType pCreateInfos->sType, is an invalid enumerator"); return false; } if(pCreateInfos->stage.sType != VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateComputePipelines parameter, VkStructureType pCreateInfos->cs.sType, is an invalid enumerator"); return false; } @@ -4020,7 +4020,7 @@ bool PostCreateComputePipelines( if(result < VK_SUCCESS) { std::string reason = "vkCreateComputePipelines parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4052,7 +4052,7 @@ bool PreCreatePipelineLayout( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreatePipelineLayout parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } @@ -4080,7 +4080,7 @@ bool PostCreatePipelineLayout( if(result < VK_SUCCESS) { std::string reason = "vkCreatePipelineLayout parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4110,49 +4110,49 @@ bool PreCreateSampler( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateSampler parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } if(pCreateInfo->magFilter < VK_FILTER_BEGIN_RANGE || pCreateInfo->magFilter > VK_FILTER_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateSampler parameter, VkFilter pCreateInfo->magFilter, is an unrecognized enumerator"); return false; } if(pCreateInfo->minFilter < VK_FILTER_BEGIN_RANGE || pCreateInfo->minFilter > VK_FILTER_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateSampler parameter, VkFilter pCreateInfo->minFilter, is an unrecognized enumerator"); return false; } if(pCreateInfo->mipmapMode < VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE || pCreateInfo->mipmapMode > VK_SAMPLER_MIPMAP_MODE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateSampler parameter, VkSamplerMipmapMode pCreateInfo->mipmapMode, is an unrecognized enumerator"); return false; } if(pCreateInfo->addressModeU < VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE || pCreateInfo->addressModeU > VK_SAMPLER_ADDRESS_MODE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressModeU, is an unrecognized enumerator"); return false; } if(pCreateInfo->addressModeV < VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE || pCreateInfo->addressModeV > VK_SAMPLER_ADDRESS_MODE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressModeV, is an unrecognized enumerator"); return false; } if(pCreateInfo->addressModeW < VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE || pCreateInfo->addressModeW > VK_SAMPLER_ADDRESS_MODE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateSampler parameter, VkTexAddress pCreateInfo->addressModeW, is an unrecognized enumerator"); return false; } @@ -4161,7 +4161,7 @@ bool PreCreateSampler( if(pCreateInfo->compareOp < VK_COMPARE_OP_BEGIN_RANGE || pCreateInfo->compareOp > VK_COMPARE_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateSampler parameter, VkCompareOp pCreateInfo->compareOp, is an unrecognized enumerator"); return false; } @@ -4169,7 +4169,7 @@ bool PreCreateSampler( if(pCreateInfo->borderColor < VK_BORDER_COLOR_BEGIN_RANGE || pCreateInfo->borderColor > VK_BORDER_COLOR_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateSampler parameter, VkBorderColor pCreateInfo->borderColor, is an unrecognized enumerator"); return false; } @@ -4191,7 +4191,7 @@ bool PostCreateSampler( if(result < VK_SUCCESS) { std::string reason = "vkCreateSampler parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4221,7 +4221,7 @@ bool PreCreateDescriptorSetLayout( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateDescriptorSetLayout parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } @@ -4230,7 +4230,7 @@ bool PreCreateDescriptorSetLayout( if(pCreateInfo->pBinding->descriptorType < VK_DESCRIPTOR_TYPE_BEGIN_RANGE || pCreateInfo->pBinding->descriptorType > VK_DESCRIPTOR_TYPE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateDescriptorSetLayout parameter, VkDescriptorType pCreateInfo->pBinding->descriptorType, is an unrecognized enumerator"); return false; } @@ -4256,7 +4256,7 @@ bool PostCreateDescriptorSetLayout( if(result < VK_SUCCESS) { std::string reason = "vkCreateDescriptorSetLayout parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4286,7 +4286,7 @@ bool PreCreateDescriptorPool( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateDescriptorPool parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } @@ -4295,7 +4295,7 @@ bool PreCreateDescriptorPool( if(pCreateInfo->pPoolSizes->type < VK_DESCRIPTOR_TYPE_BEGIN_RANGE || pCreateInfo->pPoolSizes->type > VK_DESCRIPTOR_TYPE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateDescriptorPool parameter, VkDescriptorType pCreateInfo->pTypeCount->type, is an unrecognized enumerator"); return false; } @@ -4321,7 +4321,7 @@ bool PostCreateDescriptorPool( if(result < VK_SUCCESS) { std::string reason = "vkCreateDescriptorPool parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4353,7 +4353,7 @@ bool PostResetDescriptorPool( if(result < VK_SUCCESS) { std::string reason = "vkResetDescriptorPool parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4399,7 +4399,7 @@ bool PostAllocateDescriptorSets( if(result < VK_SUCCESS) { std::string reason = "vkAllocateDescriptorSets parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4443,7 +4443,7 @@ bool PostFreeDescriptorSets( if(result < VK_SUCCESS) { std::string reason = "vkFreeDescriptorSets parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4474,14 +4474,14 @@ bool PreUpdateDescriptorSets( { if(pDescriptorWrites->sType != VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkUpdateDescriptorSets parameter, VkStructureType pDescriptorWrites->sType, is an invalid enumerator"); return false; } if(pDescriptorWrites->descriptorType < VK_DESCRIPTOR_TYPE_BEGIN_RANGE || pDescriptorWrites->descriptorType > VK_DESCRIPTOR_TYPE_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkUpdateDescriptorSets parameter, VkDescriptorType pDescriptorWrites->descriptorType, is an unrecognized enumerator"); return false; } @@ -4492,7 +4492,7 @@ bool PreUpdateDescriptorSets( if(pDescriptorWrites->pImageInfo->imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || pDescriptorWrites->pImageInfo->imageLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkUpdateDescriptorSets parameter, VkImageLayout pDescriptorWrites->pDescriptors->imageLayout, is an unrecognized enumerator"); return false; } @@ -4503,7 +4503,7 @@ bool PreUpdateDescriptorSets( { if(pDescriptorCopies->sType != VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkUpdateDescriptorSets parameter, VkStructureType pDescriptorCopies->sType, is an invalid enumerator"); return false; } @@ -4532,7 +4532,7 @@ bool PreCreateFramebuffer( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateFramebuffer parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } @@ -4557,7 +4557,7 @@ bool PostCreateFramebuffer( if(result < VK_SUCCESS) { std::string reason = "vkCreateFramebuffer parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4587,7 +4587,7 @@ bool PreCreateRenderPass( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } @@ -4596,49 +4596,49 @@ bool PreCreateRenderPass( if(pCreateInfo->pAttachments->format < VK_FORMAT_BEGIN_RANGE || pCreateInfo->pAttachments->format > VK_FORMAT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkFormat pCreateInfo->pAttachments->format, is an unrecognized enumerator"); return false; } if(pCreateInfo->pAttachments->loadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE || pCreateInfo->pAttachments->loadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->pAttachments->loadOp, is an unrecognized enumerator"); return false; } if(pCreateInfo->pAttachments->storeOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE || pCreateInfo->pAttachments->storeOp > VK_ATTACHMENT_STORE_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->pAttachments->storeOp, is an unrecognized enumerator"); return false; } if(pCreateInfo->pAttachments->stencilLoadOp < VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE || pCreateInfo->pAttachments->stencilLoadOp > VK_ATTACHMENT_LOAD_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkAttachmentLoadOp pCreateInfo->pAttachments->stencilLoadOp, is an unrecognized enumerator"); return false; } if(pCreateInfo->pAttachments->stencilStoreOp < VK_ATTACHMENT_STORE_OP_BEGIN_RANGE || pCreateInfo->pAttachments->stencilStoreOp > VK_ATTACHMENT_STORE_OP_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkAttachmentStoreOp pCreateInfo->pAttachments->stencilStoreOp, is an unrecognized enumerator"); return false; } if(pCreateInfo->pAttachments->initialLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || pCreateInfo->pAttachments->initialLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pAttachments->initialLayout, is an unrecognized enumerator"); return false; } if(pCreateInfo->pAttachments->finalLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || pCreateInfo->pAttachments->finalLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pAttachments->finalLayout, is an unrecognized enumerator"); return false; } @@ -4648,7 +4648,7 @@ bool PreCreateRenderPass( if(pCreateInfo->pSubpasses->pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE || pCreateInfo->pSubpasses->pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkPipelineBindPoint pCreateInfo->pSubpasses->pipelineBindPoint, is an unrecognized enumerator"); return false; } @@ -4657,7 +4657,7 @@ bool PreCreateRenderPass( if(pCreateInfo->pSubpasses->pInputAttachments->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE || pCreateInfo->pSubpasses->pInputAttachments->layout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pSubpasses->pInputAttachments->layout, is an unrecognized enumerator"); return false; } @@ -4667,7 +4667,7 @@ bool PreCreateRenderPass( if(pCreateInfo->pSubpasses->pColorAttachments->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE || pCreateInfo->pSubpasses->pColorAttachments->layout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pSubpasses->pColorAttachments->layout, is an unrecognized enumerator"); return false; } @@ -4677,7 +4677,7 @@ bool PreCreateRenderPass( if(pCreateInfo->pSubpasses->pResolveAttachments->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE || pCreateInfo->pSubpasses->pResolveAttachments->layout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pSubpasses->pResolveAttachments->layout, is an unrecognized enumerator"); return false; } @@ -4686,7 +4686,7 @@ bool PreCreateRenderPass( (pCreateInfo->pSubpasses->pDepthStencilAttachment->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE || pCreateInfo->pSubpasses->pDepthStencilAttachment->layout > VK_IMAGE_LAYOUT_END_RANGE)) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pSubpasses->pDepthStencilAttachment->layout, is an unrecognized enumerator"); return false; } @@ -4695,7 +4695,7 @@ bool PreCreateRenderPass( if(pCreateInfo->pSubpasses->pPreserveAttachments->layout < VK_IMAGE_LAYOUT_BEGIN_RANGE || pCreateInfo->pSubpasses->pPreserveAttachments->layout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateRenderPass parameter, VkImageLayout pCreateInfo->pSubpasses->pPreserveAttachments->layout, is an unrecognized enumerator"); return false; } @@ -4722,7 +4722,7 @@ bool PostCreateRenderPass( if(result < VK_SUCCESS) { std::string reason = "vkCreateRenderPass parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4776,7 +4776,7 @@ bool PreCreateCommandPool( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCreateCommandPool parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } @@ -4798,7 +4798,7 @@ bool PostCreateCommandPool( if(result < VK_SUCCESS) { std::string reason = "vkCreateCommandPool parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4832,7 +4832,7 @@ bool PostResetCommandPool( if(result < VK_SUCCESS) { std::string reason = "vkResetCommandPool parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4859,14 +4859,14 @@ bool PreCreateCommandBuffer( { if(pCreateInfo->sType != VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkAllocateCommandBuffers parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator"); return false; } if(pCreateInfo->level < VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE || pCreateInfo->level > VK_COMMAND_BUFFER_LEVEL_END_RANGE) { - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkAllocateCommandBuffers parameter, VkCommandBufferLevel pCreateInfo->level, is an unrecognized enumerator"); return false; } @@ -4888,7 +4888,7 @@ bool PostCreateCommandBuffer( if(result < VK_SUCCESS) { std::string reason = "vkAllocateCommandBuffers parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4917,7 +4917,7 @@ bool PreBeginCommandBuffer( { if(pBeginInfo->sType != VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkBeginCommandBuffer parameter, VkStructureType pBeginInfo->sType, is an invalid enumerator"); return false; } @@ -4934,7 +4934,7 @@ bool PostBeginCommandBuffer( if(result < VK_SUCCESS) { std::string reason = "vkBeginCommandBuffer parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4962,7 +4962,7 @@ bool PostEndCommandBuffer( if(result < VK_SUCCESS) { std::string reason = "vkEndCommandBuffer parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -4989,7 +4989,7 @@ bool PostResetCommandBuffer( if(result < VK_SUCCESS) { std::string reason = "vkResetCommandBuffer parameter, VkResult result, is " + EnumeratorString(result); - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "%s", reason.c_str()); return false; } @@ -5016,7 +5016,7 @@ bool PostCmdBindPipeline( if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE || pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdBindPipeline parameter, VkPipelineBindPoint pipelineBindPoint, is an unrecognized enumerator"); return false; } @@ -5108,7 +5108,7 @@ bool PostCmdBindDescriptorSets( if(pipelineBindPoint < VK_PIPELINE_BIND_POINT_BEGIN_RANGE || pipelineBindPoint > VK_PIPELINE_BIND_POINT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdBindDescriptorSets parameter, VkPipelineBindPoint pipelineBindPoint, is an unrecognized enumerator"); return false; } @@ -5149,7 +5149,7 @@ bool PostCmdBindIndexBuffer( if(indexType < VK_INDEX_TYPE_BEGIN_RANGE || indexType > VK_INDEX_TYPE_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdBindIndexBuffer parameter, VkIndexType indexType, is an unrecognized enumerator"); return false; } @@ -5217,13 +5217,13 @@ bool PreCmdDraw( uint32_t firstInstance) { if (vertexCount == 0) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdDraw parameter, uint32_t vertexCount, is 0"); return false; } if (instanceCount == 0) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdDraw parameter, uint32_t instanceCount, is 0"); return false; } @@ -5436,14 +5436,14 @@ bool PreCmdCopyImage( if ((pRegions->srcSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdCopyImage parameter, VkImageAspect pRegions->srcSubresource.aspectMask, is an unrecognized enumerator"); return false; } if ((pRegions->dstSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdCopyImage parameter, VkImageAspect pRegions->dstSubresource.aspectMask, is an unrecognized enumerator"); return false; } @@ -5465,7 +5465,7 @@ bool PostCmdCopyImage( if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdCopyImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator"); return false; } @@ -5474,7 +5474,7 @@ bool PostCmdCopyImage( if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdCopyImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator"); return false; } @@ -5508,14 +5508,14 @@ bool PreCmdBlitImage( if ((pRegions->srcSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdCopyImage parameter, VkImageAspect pRegions->srcSubresource.aspectMask, is an unrecognized enumerator"); return false; } if ((pRegions->dstSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdCopyImage parameter, VkImageAspect pRegions->dstSubresource.aspectMask, is an unrecognized enumerator"); return false; } @@ -5538,7 +5538,7 @@ bool PostCmdBlitImage( if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdBlitImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator"); return false; } @@ -5547,7 +5547,7 @@ bool PostCmdBlitImage( if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdBlitImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator"); return false; } @@ -5556,7 +5556,7 @@ bool PostCmdBlitImage( if(filter < VK_FILTER_BEGIN_RANGE || filter > VK_FILTER_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdBlitImage parameter, VkFilter filter, is an unrecognized enumerator"); return false; } @@ -5590,7 +5590,7 @@ bool PreCmdCopyBufferToImage( if ((pRegions->imageSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdCopyBufferToImage parameter, VkImageAspect pRegions->imageSubresource.aspectMask, is an unrecognized enumerator"); return false; } @@ -5612,7 +5612,7 @@ bool PostCmdCopyBufferToImage( if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdCopyBufferToImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator"); return false; } @@ -5645,7 +5645,7 @@ bool PreCmdCopyImageToBuffer( if ((pRegions->imageSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdCopyImageToBuffer parameter, VkImageAspect pRegions->imageSubresource.aspectMask, is an unrecognized enumerator"); return false; } @@ -5666,7 +5666,7 @@ bool PostCmdCopyImageToBuffer( if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdCopyImageToBuffer parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator"); return false; } @@ -5784,7 +5784,7 @@ bool PostCmdClearColorImage( if(imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || imageLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdClearColorImage parameter, VkImageLayout imageLayout, is an unrecognized enumerator"); return false; } @@ -5836,7 +5836,7 @@ bool PostCmdClearDepthStencilImage( if(imageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || imageLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdClearDepthStencilImage parameter, VkImageLayout imageLayout, is an unrecognized enumerator"); return false; } @@ -5901,14 +5901,14 @@ bool PreCmdResolveImage( if ((pRegions->srcSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdResolveImage parameter, VkImageAspect pRegions->srcSubresource.aspectMask, is an unrecognized enumerator"); return false; } if ((pRegions->dstSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdResolveImage parameter, VkImageAspect pRegions->dstSubresource.aspectMask, is an unrecognized enumerator"); return false; } @@ -5930,7 +5930,7 @@ bool PostCmdResolveImage( if(srcImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || srcImageLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdResolveImage parameter, VkImageLayout srcImageLayout, is an unrecognized enumerator"); return false; } @@ -5939,7 +5939,7 @@ bool PostCmdResolveImage( if(dstImageLayout < VK_IMAGE_LAYOUT_BEGIN_RANGE || dstImageLayout > VK_IMAGE_LAYOUT_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdResolveImage parameter, VkImageLayout dstImageLayout, is an unrecognized enumerator"); return false; } @@ -6271,7 +6271,7 @@ bool PreCmdBeginRenderPass( { if(pRenderPassBegin->sType != VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdBeginRenderPass parameter, VkStructureType pRenderPassBegin->sType, is an invalid enumerator"); return false; } @@ -6291,7 +6291,7 @@ bool PostCmdBeginRenderPass( if(contents < VK_SUBPASS_CONTENTS_BEGIN_RANGE || contents > VK_SUBPASS_CONTENTS_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdBeginRenderPass parameter, VkSubpassContents contents, is an unrecognized enumerator"); return false; } @@ -6319,7 +6319,7 @@ bool PostCmdNextSubpass( if(contents < VK_SUBPASS_CONTENTS_BEGIN_RANGE || contents > VK_SUBPASS_CONTENTS_END_RANGE) { - log_msg(mdd(commandBuffer), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", + log_msg(mdd(commandBuffer), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", "vkCmdNextSubpass parameter, VkSubpassContents contents, is an unrecognized enumerator"); return false; } diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp index 26c85fd8..72fb4f98 100644 --- a/layers/swapchain.cpp +++ b/layers/swapchain.cpp @@ -62,7 +62,7 @@ static void createDeviceRegisterExtensions(VkPhysicalDevice physicalDevice, cons my_device_data->deviceMap[device].pPhysicalDevice = pPhysicalDevice; pPhysicalDevice->pDevice = &my_device_data->deviceMap[device]; } else { - log_msg(my_instance_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, + log_msg(my_instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, (uint64_t)physicalDevice , 0, SWAPCHAIN_INVALID_HANDLE, "Swapchain", "vkCreateDevice() called with a non-valid VkPhysicalDevice."); } @@ -660,7 +660,7 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre } // Log the message that we've built up: skipCall |= debug_report_log_msg(my_data->report_data, - VK_DBG_REPORT_ERROR_BIT, + VK_DEBUG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, (uint64_t) device, 0, SWAPCHAIN_CREATE_SWAP_BAD_PRE_TRANSFORM, diff --git a/layers/swapchain.h b/layers/swapchain.h index 97749852..c2ee4870 100644 --- a/layers/swapchain.h +++ b/layers/swapchain.h @@ -84,19 +84,19 @@ typedef enum _SWAPCHAIN_ERROR #define LAYER_NAME (char *) "Swapchain" #define LOG_ERROR_NON_VALID_OBJ(objType, type, obj) \ (my_data) ? \ - log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (objType), \ + log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (objType), \ (uint64_t) (obj), 0, SWAPCHAIN_INVALID_HANDLE, LAYER_NAME, \ "%s() called with a non-valid %s.", __FUNCTION__, (obj)) \ : VK_FALSE #define LOG_ERROR(objType, type, obj, enm, fmt, ...) \ (my_data) ? \ - log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (objType), \ + log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT, (objType), \ (uint64_t) (obj), 0, (enm), LAYER_NAME, (fmt), __VA_ARGS__) \ : VK_FALSE #define LOG_PERF_WARNING(objType, type, obj, enm, fmt, ...) \ (my_data) ? \ - log_msg(my_data->report_data, VK_DBG_REPORT_PERF_WARN_BIT, (objType), \ + log_msg(my_data->report_data, VK_DEBUG_REPORT_PERF_WARN_BIT, (objType), \ (uint64_t) (obj), 0, (enm), LAYER_NAME, (fmt), __VA_ARGS__) \ : VK_FALSE diff --git a/layers/vk_layer_config.cpp b/layers/vk_layer_config.cpp index 53748352..6d09a18e 100755 --- a/layers/vk_layer_config.cpp +++ b/layers/vk_layer_config.cpp @@ -74,16 +74,16 @@ static VkLayerDbgAction stringToDbgAction(const char *_enum) static VkFlags stringToDbgReportFlags(const char *_enum) { // only handles single enum values - if (!strcmp(_enum, "VK_DBG_REPORT_INFO")) - return VK_DBG_REPORT_INFO_BIT; - else if (!strcmp(_enum, "VK_DBG_REPORT_WARN")) - return VK_DBG_REPORT_WARN_BIT; - else if (!strcmp(_enum, "VK_DBG_REPORT_PERF_WARN")) - return VK_DBG_REPORT_PERF_WARN_BIT; - else if (!strcmp(_enum, "VK_DBG_REPORT_ERROR")) - return VK_DBG_REPORT_ERROR_BIT; - else if (!strcmp(_enum, "VK_DBG_REPORT_DEBUG")) - return VK_DBG_REPORT_DEBUG_BIT; + if (!strcmp(_enum, "VK_DEBUG_REPORT_INFO")) + return VK_DEBUG_REPORT_INFO_BIT; + else if (!strcmp(_enum, "VK_DEBUG_REPORT_WARN")) + return VK_DEBUG_REPORT_WARN_BIT; + else if (!strcmp(_enum, "VK_DEBUG_REPORT_PERF_WARN")) + return VK_DEBUG_REPORT_PERF_WARN_BIT; + else if (!strcmp(_enum, "VK_DEBUG_REPORT_ERROR")) + return VK_DEBUG_REPORT_ERROR_BIT; + else if (!strcmp(_enum, "VK_DEBUG_REPORT_DEBUG")) + return VK_DEBUG_REPORT_DEBUG_BIT; return (VkFlags) 0; } @@ -138,15 +138,15 @@ uint32_t getLayerOptionFlags(const char *_option, uint32_t optionDefault) if (len > 0) { if (strncmp(option, "warn", len) == 0) { - flags |= VK_DBG_REPORT_WARN_BIT; + flags |= VK_DEBUG_REPORT_WARN_BIT; } else if (strncmp(option, "info", len) == 0) { - flags |= VK_DBG_REPORT_INFO_BIT; + flags |= VK_DEBUG_REPORT_INFO_BIT; } else if (strncmp(option, "perf", len) == 0) { - flags |= VK_DBG_REPORT_PERF_WARN_BIT; + flags |= VK_DEBUG_REPORT_PERF_WARN_BIT; } else if (strncmp(option, "error", len) == 0) { - flags |= VK_DBG_REPORT_ERROR_BIT; + flags |= VK_DEBUG_REPORT_ERROR_BIT; } else if (strncmp(option, "debug", len) == 0) { - flags |= VK_DBG_REPORT_DEBUG_BIT; + flags |= VK_DEBUG_REPORT_DEBUG_BIT; } } @@ -257,26 +257,26 @@ void print_msg_flags(VkFlags msgFlags, char *msg_flags) bool separator = false; msg_flags[0] = 0; - if (msgFlags & VK_DBG_REPORT_DEBUG_BIT) { + if (msgFlags & VK_DEBUG_REPORT_DEBUG_BIT) { strcat(msg_flags, "DEBUG"); separator = true; } - if (msgFlags & VK_DBG_REPORT_INFO_BIT) { + if (msgFlags & VK_DEBUG_REPORT_INFO_BIT) { if (separator) strcat(msg_flags, ","); strcat(msg_flags, "INFO"); separator = true; } - if (msgFlags & VK_DBG_REPORT_WARN_BIT) { + if (msgFlags & VK_DEBUG_REPORT_WARN_BIT) { if (separator) strcat(msg_flags, ","); strcat(msg_flags, "WARN"); separator = true; } - if (msgFlags & VK_DBG_REPORT_PERF_WARN_BIT) { + if (msgFlags & VK_DEBUG_REPORT_PERF_WARN_BIT) { if (separator) strcat(msg_flags, ","); strcat(msg_flags, "PERF"); separator = true; } - if (msgFlags & VK_DBG_REPORT_ERROR_BIT) { + if (msgFlags & VK_DEBUG_REPORT_ERROR_BIT) { if (separator) strcat(msg_flags, ","); strcat(msg_flags, "ERROR"); } diff --git a/layers/vk_layer_logging.h b/layers/vk_layer_logging.h index a7cc6bbe..110c4977 100644 --- a/layers/vk_layer_logging.h +++ b/layers/vk_layer_logging.h @@ -119,7 +119,7 @@ static inline void layer_debug_report_destroy_instance(debug_report_data *debug_ pTravNext = pTrav->pNext; debug_report_log_msg( - debug_data, VK_DBG_REPORT_WARN_BIT, + debug_data, VK_DEBUG_REPORT_WARN_BIT, VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) pTrav->msgCallback, 0, DEBUG_REPORT_CALLBACK_REF, "DebugReport", @@ -171,7 +171,7 @@ static inline VkResult layer_create_msg_callback( debug_data->active_flags |= msgFlags; debug_report_log_msg( - debug_data, VK_DBG_REPORT_DEBUG_BIT, + debug_data, VK_DEBUG_REPORT_DEBUG_BIT, VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) *pMsgCallback, 0, DEBUG_REPORT_CALLBACK_REF, "DebugReport", @@ -196,7 +196,7 @@ static inline void layer_destroy_msg_callback( debug_data->g_pDbgFunctionHead = pTrav->pNext; } debug_report_log_msg( - debug_data, VK_DBG_REPORT_DEBUG_BIT, + debug_data, VK_DEBUG_REPORT_DEBUG_BIT, VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) pTrav->msgCallback, 0, DEBUG_REPORT_NONE, "DebugReport", diff --git a/loader/debug_report.c b/loader/debug_report.c index 98fd3b46..5d3a376d 100644 --- a/loader/debug_report.c +++ b/loader/debug_report.c @@ -225,26 +225,26 @@ static void print_msg_flags(VkFlags msgFlags, char *msg_flags) bool separator = false; msg_flags[0] = 0; - if (msgFlags & VK_DBG_REPORT_DEBUG_BIT) { + if (msgFlags & VK_DEBUG_REPORT_DEBUG_BIT) { strcat(msg_flags, "DEBUG"); separator = true; } - if (msgFlags & VK_DBG_REPORT_INFO_BIT) { + if (msgFlags & VK_DEBUG_REPORT_INFO_BIT) { if (separator) strcat(msg_flags, ","); strcat(msg_flags, "INFO"); separator = true; } - if (msgFlags & VK_DBG_REPORT_WARN_BIT) { + if (msgFlags & VK_DEBUG_REPORT_WARN_BIT) { if (separator) strcat(msg_flags, ","); strcat(msg_flags, "WARN"); separator = true; } - if (msgFlags & VK_DBG_REPORT_PERF_WARN_BIT) { + if (msgFlags & VK_DEBUG_REPORT_PERF_WARN_BIT) { if (separator) strcat(msg_flags, ","); strcat(msg_flags, "PERF"); separator = true; } - if (msgFlags & VK_DBG_REPORT_ERROR_BIT) { + if (msgFlags & VK_DEBUG_REPORT_ERROR_BIT) { if (separator) strcat(msg_flags, ","); strcat(msg_flags, "ERROR"); } diff --git a/loader/loader.c b/loader/loader.c index 0b0e1306..5673be41 100644 --- a/loader/loader.c +++ b/loader/loader.c @@ -291,7 +291,7 @@ static char *loader_get_registry_files(const struct loader_instance *inst, char total_size *= 2; } if (out == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory, failed loader_get_registry_files"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory, failed loader_get_registry_files"); return NULL; } if (strlen(out) == 0) @@ -467,7 +467,7 @@ static struct loader_layer_properties *loader_get_next_layer_property( sizeof(struct loader_layer_properties) * 64, 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"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't add any layer properties to list"); return NULL; } memset(layer_list->list, 0, sizeof(struct loader_layer_properties) * 64); @@ -482,7 +482,7 @@ static struct loader_layer_properties *loader_get_next_layer_property( layer_list->capacity * 2, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (layer_list->list == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "realloc failed for layer list"); } layer_list->capacity *= 2; @@ -543,7 +543,7 @@ static void loader_add_global_extensions( res = fp_get_props(NULL, &count, NULL); if (res != VK_SUCCESS) { - loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Error getting global extension count from %s", lib_name); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Error getting global extension count from %s", lib_name); return; } @@ -556,7 +556,7 @@ static void loader_add_global_extensions( res = fp_get_props(NULL, &count, ext_props); if (res != VK_SUCCESS) { - loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Error getting global extensions from %s", lib_name); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Error getting global extensions from %s", lib_name); return; } @@ -567,7 +567,7 @@ static void loader_add_global_extensions( VK_MAJOR(ext_props[i].specVersion), VK_MINOR(ext_props[i].specVersion), VK_PATCH(ext_props[i].specVersion)); - loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, + loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "Global Extension: %s (%s) version %s", ext_props[i].extensionName, lib_name, spec_version); loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]); @@ -602,7 +602,7 @@ static VkResult loader_init_physical_device_extensions( VK_MAJOR(ext_props[i].specVersion), VK_MINOR(ext_props[i].specVersion), VK_PATCH(ext_props[i].specVersion)); - loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, + loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "PhysicalDevice Extension: %s (%s) version %s", ext_props[i].extensionName, phys_dev->this_icd->this_icd_lib->lib_name, spec_version); res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]); @@ -638,7 +638,7 @@ static VkResult loader_add_physical_device_extensions( VK_MAJOR(ext_props[i].specVersion), VK_MINOR(ext_props[i].specVersion), VK_PATCH(ext_props[i].specVersion)); - loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, + loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "PhysicalDevice Extension: %s (%s) version %s", ext_props[i].extensionName, lib_name, spec_version); res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]); @@ -646,7 +646,7 @@ static VkResult loader_add_physical_device_extensions( return res; } } else { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Error getting physical device extension info count from library %s", lib_name); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Error getting physical device extension info count from library %s", lib_name); return res; } @@ -809,7 +809,7 @@ static VkResult loader_add_layer_names_to_list( const char *search_target = names[i]; layer_prop = loader_get_layer_property(search_target, search_list); if (!layer_prop) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Unable to find layer %s", search_target); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Unable to find layer %s", search_target); err = VK_ERROR_LAYER_NOT_PRESENT; continue; } @@ -1020,7 +1020,7 @@ static void loader_find_layer_name_add_list( } } if (!found) { - loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Warning, couldn't find layer name %s to activate", name); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Warning, couldn't find layer name %s to activate", name); } } @@ -1070,7 +1070,7 @@ void loader_get_icd_loader_instance_extensions( struct loader_extension_list *inst_exts) { struct loader_extension_list icd_exts; - loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, "Build ICD instance extension list"); + loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "Build ICD instance extension list"); // traverse scanned icd list adding non-duplicate extensions to the list for (uint32_t i = 0; i < icd_libs->count; i++) { loader_init_generic_list(inst, (struct loader_generic_list *) &icd_exts, @@ -1139,7 +1139,7 @@ static struct loader_device *loader_add_logical_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"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to alloc struct laoder-device"); return NULL; } @@ -1266,14 +1266,14 @@ static void loader_scanned_icd_add( // Used to call: dlopen(filename, RTLD_LAZY); handle = loader_platform_open_library(filename); if (!handle) { - loader_log(VK_DBG_REPORT_WARN_BIT, 0, loader_platform_open_library_error(filename)); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, loader_platform_open_library_error(filename)); return; } #define LOOKUP_LD(func_ptr, func) do { \ func_ptr = (PFN_vk ##func) loader_platform_get_proc_address(handle, "vk" #func); \ if (!func_ptr) { \ - loader_log(VK_DBG_REPORT_WARN_BIT, 0, loader_platform_get_proc_address_error("vk" #func)); \ + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, loader_platform_get_proc_address_error("vk" #func)); \ return; \ } \ } while (0) @@ -1307,7 +1307,7 @@ static void loader_scanned_icd_add( strlen(filename) + 1, 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"); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Out of memory can't add icd"); return; } strcpy(new_node->lib_name, filename); @@ -1323,7 +1323,7 @@ static bool loader_icd_init_entrys(struct loader_icd *icd, #define LOOKUP_GIPA(func, required) do { \ icd->func = (PFN_vk ##func) fp_gipa(inst, "vk" #func); \ if (!icd->func && required) { \ - loader_log(VK_DBG_REPORT_WARN_BIT, 0, \ + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, \ loader_platform_get_proc_address_error("vk" #func)); \ return false; \ } \ @@ -1385,19 +1385,19 @@ static void loader_debug_init(void) g_loader_log_msgs = ~0u; } else if (strncmp(env, "warn", len) == 0) { g_loader_debug |= LOADER_WARN_BIT; - g_loader_log_msgs |= VK_DBG_REPORT_WARN_BIT; + g_loader_log_msgs |= VK_DEBUG_REPORT_WARN_BIT; } else if (strncmp(env, "info", len) == 0) { g_loader_debug |= LOADER_INFO_BIT; - g_loader_log_msgs |= VK_DBG_REPORT_INFO_BIT; + g_loader_log_msgs |= VK_DEBUG_REPORT_INFO_BIT; } else if (strncmp(env, "perf", len) == 0) { g_loader_debug |= LOADER_PERF_BIT; - g_loader_log_msgs |= VK_DBG_REPORT_PERF_WARN_BIT; + g_loader_log_msgs |= VK_DEBUG_REPORT_PERF_WARN_BIT; } else if (strncmp(env, "error", len) == 0) { g_loader_debug |= LOADER_ERROR_BIT; - g_loader_log_msgs |= VK_DBG_REPORT_ERROR_BIT; + g_loader_log_msgs |= VK_DEBUG_REPORT_ERROR_BIT; } else if (strncmp(env, "debug", len) == 0) { g_loader_debug |= LOADER_DEBUG_BIT; - g_loader_log_msgs |= VK_DBG_REPORT_DEBUG_BIT; + g_loader_log_msgs |= VK_DEBUG_REPORT_DEBUG_BIT; } } @@ -1527,7 +1527,7 @@ static cJSON *loader_get_json(const char *filename) uint64_t len; file = fopen(filename,"rb"); if (!file) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Couldn't open JSON file %s", filename); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Couldn't open JSON file %s", filename); return NULL; } fseek(file, 0, SEEK_END); @@ -1535,12 +1535,12 @@ static cJSON *loader_get_json(const char *filename) fseek(file, 0, SEEK_SET); json_buf = (char*) loader_stack_alloc(len+1); if (json_buf == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get JSON file"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't get JSON file"); fclose(file); return NULL; } if (fread(json_buf, sizeof(char), len, file) != len) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "fread failed can't get JSON file"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "fread failed can't get JSON file"); fclose(file); return NULL; } @@ -1550,7 +1550,7 @@ static cJSON *loader_get_json(const char *filename) //parse text from file json = cJSON_Parse(json_buf); if (json == NULL) - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Can't parse JSON file %s", filename); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Can't parse JSON file %s", filename); return json; } @@ -1645,15 +1645,15 @@ static void loader_add_layer_properties(const struct loader_instance *inst, return; } char *file_vers = cJSON_PrintUnformatted(item); - loader_log(VK_DBG_REPORT_INFO_BIT, 0, "Found manifest file %s, version %s", + loader_log(VK_DEBUG_REPORT_INFO_BIT, 0, "Found manifest file %s, version %s", filename, file_vers); if (strcmp(file_vers, "\"1.0.0\"") != 0) - loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Unexpected manifest file version (expected 1.0.0), may cause errors"); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Unexpected manifest file version (expected 1.0.0), may cause errors"); loader_tls_heap_free(file_vers); layer_node = cJSON_GetObjectItem(json, "layer"); if (layer_node == NULL) { - loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Can't find \"layer\" object in manifest JSON file, skipping"); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Can't find \"layer\" object in manifest JSON file, skipping"); return; } @@ -1936,7 +1936,7 @@ static void loader_get_manifest_files(const struct loader_instance *inst, } if (location == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Can't get manifest files with NULL location, env_override=%s", env_override); return; @@ -1952,14 +1952,14 @@ static void loader_get_manifest_files(const struct loader_instance *inst, if (override == NULL) { loc = loader_stack_alloc(strlen(location) + 1); if (loc == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files"); return; } strcpy(loc, location); #if defined(_WIN32) loc = loader_get_registry_files(inst, loc); if (loc == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Registry lookup failed can't get manifest files"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Registry lookup failed can't get manifest files"); return; } #endif @@ -1967,14 +1967,14 @@ static void loader_get_manifest_files(const struct loader_instance *inst, else { loc = loader_stack_alloc(strlen(override) + 1); if (loc == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files"); return; } strcpy(loc, override); } // Print out the paths being searched if debugging is enabled - loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, "Searching the following paths for manifest files: %s\n", loc); + loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "Searching the following paths for manifest files: %s\n", loc); file = loc; while (*file) { @@ -2000,7 +2000,7 @@ static void loader_get_manifest_files(const struct loader_instance *inst, // make a copy of location so it isn't modified dir = loader_stack_alloc(strlen(loc) + 1); if (dir == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files"); return; } strcpy(dir, loc); @@ -2029,7 +2029,7 @@ static void loader_get_manifest_files(const struct loader_instance *inst, alloced_count *= 2; } if (out_files->filename_list == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't alloc manifest file list"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't alloc manifest file list"); return; } out_files->filename_list[out_files->count] = loader_heap_alloc( @@ -2037,13 +2037,13 @@ static void loader_get_manifest_files(const struct loader_instance *inst, strlen(name) + 1, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); 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"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files"); return; } strcpy(out_files->filename_list[out_files->count], name); out_files->count++; } else if (!list_is_dirs) { - loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Skipping manifest file %s, file name must end in .json", name); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Skipping manifest file %s, file name must end in .json", name); } if (list_is_dirs) { dent = readdir(sysdir); @@ -2114,10 +2114,10 @@ void loader_icd_scan( return; } char *file_vers = cJSON_Print(item); - loader_log(VK_DBG_REPORT_INFO_BIT, 0, "Found manifest file %s, version %s", + loader_log(VK_DEBUG_REPORT_INFO_BIT, 0, "Found manifest file %s, version %s", file_str, file_vers); if (strcmp(file_vers, "\"1.0.0\"") != 0) - loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Unexpected manifest file version (expected 1.0.0), may cause errors"); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Unexpected manifest file version (expected 1.0.0), may cause errors"); loader_tls_heap_free(file_vers); itemICD = cJSON_GetObjectItem(json, "ICD"); if (itemICD != NULL) { @@ -2125,7 +2125,7 @@ void loader_icd_scan( if (item != NULL) { char *temp= cJSON_Print(item); if (!temp || strlen(temp) == 0) { - loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" in ICD JSON file %s, skipping", file_str); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" in ICD JSON file %s, skipping", file_str); loader_tls_heap_free(temp); loader_heap_free(inst, file_str); cJSON_Delete(json); @@ -2137,14 +2137,14 @@ void loader_icd_scan( strcpy(library_path, &temp[1]); loader_tls_heap_free(temp); if (!library_path || strlen(library_path) == 0) { - loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" in ICD JSON file %s, skipping", file_str); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" in ICD JSON file %s, skipping", file_str); loader_heap_free(inst, file_str); cJSON_Delete(json); continue; } char fullpath[MAX_STRING_SIZE]; // Print out the paths being searched if debugging is enabled - loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, "Searching for ICD drivers named %s default dir %s\n", library_path, DEFAULT_VK_DRIVERS_PATH); + loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "Searching for ICD drivers named %s default dir %s\n", library_path, DEFAULT_VK_DRIVERS_PATH); if (loader_platform_is_path(library_path)) { // a relative or absolute path char *name_copy = loader_stack_alloc(strlen(file_str) + 1); @@ -2167,10 +2167,10 @@ void loader_icd_scan( loader_scanned_icd_add(inst, icds, fullpath, vers); } else - loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" object in ICD JSON file %s, skipping", file_str); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Can't find \"library_path\" object in ICD JSON file %s, skipping", file_str); } else - loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Can't find \"ICD\" object in ICD JSON file %s, skipping", file_str); + loader_log(VK_DEBUG_REPORT_WARN_BIT, 0, "Can't find \"ICD\" object in ICD JSON file %s, skipping", file_str); loader_heap_free(inst, file_str); cJSON_Delete(json); @@ -2204,7 +2204,7 @@ void loader_layer_scan( * used to check for global and physicaldevice layer properties. */ if (!loader_init_layer_library_list(&loader.scanned_layer_libraries)) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Alloc for layer list failed: %s line: %d", __FILE__, __LINE__); return; } @@ -2361,7 +2361,7 @@ static bool loader_add_dev_ext_table(struct loader_instance *inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (inst->disp_hash[idx].func_name == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "loader_add_dev_ext_table() can't allocate memory for func_name"); return false; } @@ -2374,7 +2374,7 @@ static bool loader_add_dev_ext_table(struct loader_instance *inst, list->index = loader_heap_alloc(inst, 8 * sizeof(*(list->index)), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (list->index == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "loader_add_dev_ext_table() can't allocate list memory"); return false; } @@ -2384,7 +2384,7 @@ static bool loader_add_dev_ext_table(struct loader_instance *inst, list->capacity * 2, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (list->index == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "loader_add_dev_ext_table() can't reallocate list memory"); return false; } @@ -2400,7 +2400,7 @@ static bool loader_add_dev_ext_table(struct loader_instance *inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (inst->disp_hash[i].func_name == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "loader_add_dev_ext_table() can't rallocate func_name memory"); return false; } @@ -2413,7 +2413,7 @@ static bool loader_add_dev_ext_table(struct loader_instance *inst, i = (i + 1) % MAX_NUM_DEV_EXTS; } while (i != idx); - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "loader_add_dev_ext_table() couldn't insert into hash table; is it full?"); return false; } @@ -2517,7 +2517,7 @@ static loader_platform_dl_handle loader_add_layer_lib( if (strcmp(loader.loaded_layer_lib_list[i].lib_name, layer_prop->lib_name) == 0) { /* Have already loaded this library, just increment ref count */ loader.loaded_layer_lib_list[i].ref_count++; - loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, + loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "%s Chain: Increment layer reference count for layer library %s", chain_type, layer_prop->lib_name); return loader.loaded_layer_lib_list[i].lib_handle; @@ -2539,7 +2539,7 @@ static loader_platform_dl_handle loader_add_layer_lib( new_alloc_size, 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"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "loader: realloc failed in loader_add_layer_lib"); return NULL; } loader.loaded_layer_lib_capacity = new_alloc_size; @@ -2553,11 +2553,11 @@ static loader_platform_dl_handle loader_add_layer_lib( my_lib->lib_handle = NULL; if ((my_lib->lib_handle = loader_platform_open_library(my_lib->lib_name)) == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, loader_platform_open_library_error(my_lib->lib_name)); return NULL; } else { - loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, + loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "Chain: %s: Loading layer library %s", chain_type, layer_prop->lib_name); } @@ -2587,13 +2587,13 @@ static void loader_remove_layer_lib( if (my_lib) { my_lib->ref_count--; if (my_lib->ref_count > 0) { - loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, + loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "Decrement reference count for layer library %s", layer_prop->lib_name); return; } } loader_platform_close_library(my_lib->lib_handle); - loader_log(VK_DBG_REPORT_DEBUG_BIT, 0, + loader_log(VK_DEBUG_REPORT_DEBUG_BIT, 0, "Unloading layer library %s", layer_prop->lib_name); /* Need to remove unused library from list */ @@ -2601,7 +2601,7 @@ static void loader_remove_layer_lib( loader.loaded_layer_lib_capacity, 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"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "loader: heap alloc failed loader_remove_layer_library"); return; } @@ -2703,7 +2703,7 @@ VkResult loader_enable_instance_layers( assert(inst && "Cannot have null instance"); if (!loader_init_layer_list(inst, &inst->activated_layer_list)) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc Instance activated layer list"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to alloc Instance activated layer list"); return VK_ERROR_OUT_OF_HOST_MEMORY; } @@ -2756,7 +2756,7 @@ uint32_t loader_activate_instance_layers(struct loader_instance *inst) wrappedInstance = loader_stack_alloc(sizeof(VkBaseLayerObject) * inst->activated_layer_list.count); if (!wrappedInstance) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc Instance objects for layer"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to alloc Instance objects for layer"); return 0; } @@ -2796,14 +2796,14 @@ uint32_t loader_activate_instance_layers(struct loader_instance *inst) } else nextGPA = (PFN_vkGetInstanceProcAddr) loader_platform_get_proc_address(lib_handle, layer_prop->functions.str_gipa); if (!nextGPA) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to find vkGetInstanceProcAddr in layer %s", layer_prop->lib_name); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to find vkGetInstanceProcAddr in layer %s", layer_prop->lib_name); /* TODO: Should we return nextObj, nextGPA to previous? or decrement layer_list count*/ continue; } } - loader_log(VK_DBG_REPORT_INFO_BIT, 0, + loader_log(VK_DEBUG_REPORT_INFO_BIT, 0, "Insert instance layer %s (%s)", layer_prop->info.layerName, layer_prop->lib_name); @@ -2841,7 +2841,7 @@ static VkResult loader_enable_device_layers( } if (dev->activated_layer_list.list == NULL) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc device activated layer list"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to alloc device activated layer list"); return VK_ERROR_OUT_OF_HOST_MEMORY; } @@ -2925,7 +2925,7 @@ static uint32_t loader_activate_device_layers( sizeof (VkBaseLayerObject) * dev->activated_layer_list.count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (!wrappedGpus) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc Gpu objects for layer"); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to alloc Gpu objects for layer"); return 0; } @@ -2948,12 +2948,12 @@ static uint32_t loader_activate_device_layers( } else nextGPA = (PFN_vkGetDeviceProcAddr) loader_platform_get_proc_address(lib_handle, layer_prop->functions.str_gdpa); if (!nextGPA) { - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to find vkGetDeviceProcAddr in layer %s", layer_prop->lib_name); + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "Failed to find vkGetDeviceProcAddr in layer %s", layer_prop->lib_name); continue; } } - loader_log(VK_DBG_REPORT_INFO_BIT, 0, + loader_log(VK_DEBUG_REPORT_INFO_BIT, 0, "Insert device layer library %s (%s)", layer_prop->info.layerName, layer_prop->lib_name); @@ -3134,7 +3134,7 @@ VKAPI_ATTR VkResult VKAPI_CALL loader_CreateInstance( ptr_instance->icds = ptr_instance->icds->next; loader_icd_destroy(ptr_instance, icd); icd->instance = VK_NULL_HANDLE; - loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + loader_log(VK_DEBUG_REPORT_ERROR_BIT, 0, "ICD ignored: failed to CreateInstance and find entrypoints with ICD"); } } diff --git a/vk-layer-generate.py b/vk-layer-generate.py index 466ba4e1..92a52dd5 100755 --- a/vk-layer-generate.py +++ b/vk-layer-generate.py @@ -738,7 +738,7 @@ class GenericLayerSubcommand(Subcommand): ' char str[1024];\n' ' layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);\n' ' sprintf(str, "At start of Generic layered %s\\n");\n' - ' log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE,' + ' log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE,' ' (uint64_t)physicalDevice, 0, 0, (char *) "Generic", "%%s", (char *) str);\n' ' %sdevice_dispatch_table(*pDevice)->%s;\n' ' if (result == VK_SUCCESS) {\n' @@ -746,7 +746,7 @@ class GenericLayerSubcommand(Subcommand): ' createDeviceRegisterExtensions(pCreateInfo, *pDevice);\n' ' }\n' ' sprintf(str, "Completed Generic layered %s\\n");\n' - ' log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, (uint64_t)physicalDevice, 0, 0, (char *) "Generic", "%%s", (char *) str);\n' + ' log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, (uint64_t)physicalDevice, 0, 0, (char *) "Generic", "%%s", (char *) str);\n' ' %s' '}' % (qual, decl, proto.name, ret_val, proto.c_call(), proto.name, stmt)) elif proto.name == "DestroyDevice": @@ -793,7 +793,7 @@ class GenericLayerSubcommand(Subcommand): ' pCreateInfo->ppEnabledExtensionNames);\n' ' initGeneric(my_data);\n' ' sprintf(str, "Completed Generic layered %s\\n");\n' - ' log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_INSTANCE, (uint64_t)*pInstance, 0, 0, (char *) "Generic", "%%s", (char *) str);\n' + ' log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT, VK_OBJECT_TYPE_INSTANCE, (uint64_t)*pInstance, 0, 0, (char *) "Generic", "%%s", (char *) str);\n' ' }\n' ' return result;\n' '}\n' % (qual, decl, ret_val, proto.c_call(), proto.name)) @@ -1315,7 +1315,7 @@ class ObjectTrackerSubcommand(Subcommand): else: procs_txt.append('static void create_%s(VkDevice dispatchable_object, %s vkObj, VkDbgObjectType objType)' % (name, o)) procs_txt.append('{') - procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast(vkObj), 0, OBJTRACK_NONE, "OBJTRACK",') + procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT, objType, reinterpret_cast(vkObj), 0, OBJTRACK_NONE, "OBJTRACK",') procs_txt.append(' "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),') procs_txt.append(' reinterpret_cast(vkObj));') procs_txt.append('') @@ -1343,7 +1343,7 @@ class ObjectTrackerSubcommand(Subcommand): procs_txt.append('{') if o in vulkan.object_dispatch_list: procs_txt.append(' if (%sMap.find((uint64_t)object) == %sMap.end()) {' % (o, o)) - procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",') + procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType ) 0, reinterpret_cast(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",') procs_txt.append(' "Invalid %s Object 0x%%" PRIx64 ,reinterpret_cast(object));' % o) else: if o == "VkImage": @@ -1352,7 +1352,7 @@ class ObjectTrackerSubcommand(Subcommand): procs_txt.append(' (swapchainImageMap.find((uint64_t)object) == swapchainImageMap.end())) {') else: procs_txt.append(' if (%sMap.find((uint64_t)object) == %sMap.end()) {' % (o, o)) - procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",') + procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType ) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",') procs_txt.append(' "Invalid %s Object 0x%%" PRIx64, reinterpret_cast(object));' % o) procs_txt.append(' }') procs_txt.append(' return VK_FALSE;') @@ -1373,14 +1373,14 @@ class ObjectTrackerSubcommand(Subcommand): procs_txt.append(' numTotalObjs--;') procs_txt.append(' assert(numObjs[objIndex] > 0);') procs_txt.append(' numObjs[objIndex]--;') - procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, object_handle, 0, OBJTRACK_NONE, "OBJTRACK",') + procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT, pNode->objType, object_handle, 0, OBJTRACK_NONE, "OBJTRACK",') procs_txt.append(' "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).",') procs_txt.append(' string_VkDbgObjectType(pNode->objType), reinterpret_cast(object), numTotalObjs, numObjs[objIndex],') procs_txt.append(' string_VkDbgObjectType(pNode->objType));') procs_txt.append(' delete pNode;') procs_txt.append(' %sMap.erase(object_handle);' % (o)) procs_txt.append(' } else {') - procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object_handle, 0, OBJTRACK_NONE, "OBJTRACK",') + procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType ) 0, object_handle, 0, OBJTRACK_NONE, "OBJTRACK",') procs_txt.append(' "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",') procs_txt.append(' object_handle);') procs_txt.append(' }') @@ -1400,7 +1400,7 @@ class ObjectTrackerSubcommand(Subcommand): procs_txt.append(' }') procs_txt.append(' else {') procs_txt.append(' // If we do not find it print an error') - procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object_handle, 0, OBJTRACK_NONE, "OBJTRACK",') + procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType ) 0, object_handle, 0, OBJTRACK_NONE, "OBJTRACK",') procs_txt.append(' "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",') procs_txt.append(' object_handle, string_VkDbgObjectType(objType));') procs_txt.append(' }') @@ -1454,7 +1454,7 @@ class ObjectTrackerSubcommand(Subcommand): procs_txt.append(' }') procs_txt.append(' else {') procs_txt.append(' // If we do not find it print an error') - procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, objType, object_handle, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",') + procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, objType, object_handle, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",') procs_txt.append(' "Unable to reset status for non-existent object 0x%" PRIxLEAST64 " of %s type",') procs_txt.append(' object_handle, string_VkDbgObjectType(objType));') procs_txt.append(' }') @@ -1480,7 +1480,7 @@ class ObjectTrackerSubcommand(Subcommand): continue gedi_txt.append(' for (auto it = %sMap.begin(); it != %sMap.end(); ++it) {' % (o, o)) gedi_txt.append(' OBJTRACK_NODE* pNode = it->second;') - gedi_txt.append(' log_msg(mid(instance), VK_DBG_REPORT_ERROR_BIT, pNode->objType, pNode->vkObj, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK",') + gedi_txt.append(' log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT, pNode->objType, pNode->vkObj, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK",') gedi_txt.append(' "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDbgObjectType(pNode->objType),') gedi_txt.append(' pNode->vkObj);') gedi_txt.append(' }') @@ -1530,7 +1530,7 @@ class ObjectTrackerSubcommand(Subcommand): continue gedd_txt.append(' for (auto it = %sMap.begin(); it != %sMap.end(); ++it) {' % (o, o)) gedd_txt.append(' OBJTRACK_NODE* pNode = it->second;') - gedd_txt.append(' log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, pNode->objType, pNode->vkObj, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK",') + gedd_txt.append(' log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT, pNode->objType, pNode->vkObj, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK",') gedd_txt.append(' "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDbgObjectType(pNode->objType),') gedd_txt.append(' pNode->vkObj);') gedd_txt.append(' }') @@ -1562,7 +1562,7 @@ class ObjectTrackerSubcommand(Subcommand): cbv_txt.append('{') cbv_txt.append(' uint64_t object_handle = reinterpret_cast(object);') cbv_txt.append(' if (%sMap.find(object_handle) == %sMap.end()) {' % (o, o)) - cbv_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object_handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",') + cbv_txt.append(' return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, (VkDbgObjectType ) 0, object_handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",') cbv_txt.append(' "Invalid %s Object 0x%%" PRIx64, object_handle);' % (o)) cbv_txt.append(' }') cbv_txt.append(' return VK_FALSE;') @@ -1893,7 +1893,7 @@ class ThreadingSubcommand(Subcommand): header_txt.append(' %sObjectsInUse[%s] = tid;' % (ty, key)) header_txt.append(' } else {') header_txt.append(' if (%sObjectsInUse[%s] != tid) {' % (ty, key)) - header_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, %s, %s,' % (obj_type, msg_object)) + header_txt.append(' log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, %s, %s,' % (obj_type, msg_object)) header_txt.append(' /*location*/ 0, THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",') header_txt.append(' "THREADING ERROR : object of type %s is simultaneously used in thread %%ld and thread %%ld",' % (ty)) header_txt.append(' %sObjectsInUse[%s], tid);' % (ty, key)) @@ -1903,7 +1903,7 @@ class ThreadingSubcommand(Subcommand): header_txt.append(' }') header_txt.append(' %sObjectsInUse[%s] = tid;' % (ty, key)) header_txt.append(' } else {') - header_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, %s, %s,' % (obj_type, msg_object)) + header_txt.append(' log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT, %s, %s,' % (obj_type, msg_object)) header_txt.append(' /*location*/ 0, THREADING_CHECKER_MULTIPLE_THREADS, "THREADING",') header_txt.append(' "THREADING ERROR : object of type %s is recursively used in thread %%ld",' % (ty)) header_txt.append(' tid);') -- cgit v1.2.3