debug_report: rename and update to use CreateInfo
diff --git a/include/vulkan/vk_layer.h b/include/vulkan/vk_layer.h
index 471f8ff..5ac2f7e 100644
--- a/include/vulkan/vk_layer.h
+++ b/include/vulkan/vk_layer.h
@@ -174,8 +174,8 @@
PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
- PFN_vkDbgCreateMsgCallback DbgCreateMsgCallback;
- PFN_vkDbgDestroyMsgCallback DbgDestroyMsgCallback;
+ PFN_vkCreateDebugReportCallbackLUNARG CreateDebugReportCallbackLUNARG;
+ PFN_vkDestroyDebugReportCallbackLUNARG DestroyDebugReportCallbackLUNARG;
#ifdef VK_USE_PLATFORM_MIR_KHR
PFN_vkCreateMirSurfaceKHR CreateMirSurfaceKHR;
PFN_vkGetPhysicalDeviceMirPresentationSupportKHR GetPhysicalDeviceMirPresentationSupportKHR;
@@ -205,7 +205,7 @@
typedef struct VkLayerDbgFunctionNode_
{
VkDebugReportCallbackLUNARG msgCallback;
- PFN_vkDbgMsgCallback pfnMsgCallback;
+ PFN_vkDebugReportCallbackLUNARG pfnMsgCallback;
VkFlags msgFlags;
const void *pUserData;
struct VkLayerDbgFunctionNode_ *pNext;
diff --git a/include/vulkan/vk_lunarg_debug_report.h b/include/vulkan/vk_lunarg_debug_report.h
index 5fc3de0..936625f 100644
--- a/include/vulkan/vk_lunarg_debug_report.h
+++ b/include/vulkan/vk_lunarg_debug_report.h
@@ -110,11 +110,12 @@
#define VK_OBJECT_TYPE_MSG_CALLBACK VK_DEBUG_REPORT_ENUM_EXTEND(VkDebugReportObjectTypeLUNARG, 0)
#define VK_ERROR_VALIDATION_FAILED VK_DEBUG_REPORT_ENUM_EXTEND(VkResult, 0)
+#define VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG VK_DEBUG_REPORT_ENUM_EXTEND(VkStructureType, 0)
// ------------------------------------------------------------------------------------------------
// Vulkan function pointers
-typedef VkBool32 (*PFN_vkDbgMsgCallback)(
+typedef VkBool32 (*PFN_vkDebugReportCallbackLUNARG)(
VkFlags msgFlags,
VkDebugReportObjectTypeLUNARG objType,
uint64_t srcObject,
@@ -124,26 +125,33 @@
const char* pMsg,
const void* pUserData);
+typedef struct VkDebugReportCallbackCreateInfoLUNARG {
+ VkStructureType sType;
+ const void* pNext;
+ VkDebugReportFlagsLUNARG flags;
+ PFN_vkDebugReportCallbackLUNARG pfnCallback;
+ const void* pUserData;
+} VkDebugReportCallbackCreateInfoLUNARG;
+
// ------------------------------------------------------------------------------------------------
// API functions
-typedef VkResult (VKAPI_PTR *PFN_vkDbgCreateMsgCallback)(VkInstance instance, VkFlags msgFlags, const PFN_vkDbgMsgCallback pfnMsgCallback, void* pUserData, VkDebugReportCallbackLUNARG* pMsgCallback);
-typedef VkResult (VKAPI_PTR *PFN_vkDbgDestroyMsgCallback)(VkInstance instance, VkDebugReportCallbackLUNARG msgCallback);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackLUNARG)(VkInstance instance, VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackLUNARG* pCallback);
+typedef VkResult (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackLUNARG)(VkInstance instance, VkDebugReportCallbackLUNARG callback, const VkAllocationCallbacks *pAllocator);
#ifdef VK_PROTOTYPES
// DebugReport extension entrypoints
-VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
- VkInstance instance,
- VkFlags msgFlags,
- const PFN_vkDbgMsgCallback pfnMsgCallback,
- void* pUserData,
- VkDebugReportCallbackLUNARG* pMsgCallback);
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
+ VkInstance instance,
+ VkDebugReportCallbackCreateInfoLUNARG* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackLUNARG* pCallback);
-VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
- VkInstance instance,
- VkDebugReportCallbackLUNARG msgCallback);
-
+VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
+ VkInstance instance,
+ VkDebugReportCallbackLUNARG callback,
+ const VkAllocationCallbacks* pAllocator);
#endif // VK_PROTOTYPES
#ifdef __cplusplus
diff --git a/layers/device_limits.cpp b/layers/device_limits.cpp
index c4e67c2..d57ce6d 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -114,12 +114,24 @@
{
option_str = getLayerOption("DeviceLimitsLogFilename");
log_output = getLayerLogOutput(option_str, "DeviceLimits");
- layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &callback);
+ VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;
+ memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
+ dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgCreateInfo.flags = report_flags;
+ dbgCreateInfo.pfnCallback = log_callback;
+ dbgCreateInfo.pUserData = (void *) log_output;
+ layer_create_msg_callback(my_data->report_data, &dbgCreateInfo, pAllocator, &callback);
my_data->logging_callback.push_back(callback);
}
if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
- layer_create_msg_callback(my_data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+ VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;
+ memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
+ dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgCreateInfo.flags = report_flags;
+ dbgCreateInfo.pfnCallback = win32_debug_output_msg;
+ dbgCreateInfo.pUserData = NULL;
+ layer_create_msg_callback(my_data->report_data, &dbgCreateInfo, pAllocator, &callback);
my_data->logging_callback.push_back(callback);
}
@@ -191,7 +203,7 @@
// Clean up logging callback, if any
while (my_data->logging_callback.size() > 0) {
VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
- layer_destroy_msg_callback(my_data->report_data, callback);
+ layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
my_data->logging_callback.pop_back();
}
@@ -550,29 +562,28 @@
dev_data->device_dispatch_table->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
- VkInstance instance,
- VkFlags msgFlags,
- const PFN_vkDbgMsgCallback pfnMsgCallback,
- void* pUserData,
- VkDebugReportCallbackLUNARG* pMsgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
+ VkInstance instance,
+ VkDebugReportCallbackCreateInfoLUNARG* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackLUNARG* pMsgCallback)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
- VkResult res = my_data->instance_dispatch_table->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ VkResult res = my_data->instance_dispatch_table->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
if (VK_SUCCESS == res) {
- res = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ res = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback);
}
return res;
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
- VkInstance instance,
- VkDebugReportCallbackLUNARG msgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
+ VkInstance instance,
+ VkDebugReportCallbackLUNARG msgCallback,
+ const VkAllocationCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
- VkResult res = my_data->instance_dispatch_table->DbgDestroyMsgCallback(instance, msgCallback);
- layer_destroy_msg_callback(my_data->report_data, msgCallback);
- return res;
+ my_data->instance_dispatch_table->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
+ layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
}
VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char* funcName)
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 5ad5ee4..c2afbdc 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -2569,12 +2569,24 @@
{
option_str = getLayerOption("DrawStateLogFilename");
log_output = getLayerLogOutput(option_str, "DrawState");
- layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &callback);
+ VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+ memset(&dbgInfo, 0, sizeof(dbgInfo));
+ dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgInfo.pfnCallback = log_callback;
+ dbgInfo.pUserData = log_output;
+ dbgInfo.flags = report_flags;
+ layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback);
my_data->logging_callback.push_back(callback);
}
if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
- layer_create_msg_callback(my_data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+ VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+ memset(&dbgInfo, 0, sizeof(dbgInfo));
+ dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgInfo.pfnCallback = win32_debug_output_msg;
+ dbgInfo.pUserData = log_output;
+ dbgInfo.flags = report_flags;
+ layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback);
my_data->logging_callback.push_back(callback);
}
@@ -2617,7 +2629,7 @@
// Clean up logging callback, if any
while (my_data->logging_callback.size() > 0) {
VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
- layer_destroy_msg_callback(my_data->report_data, callback);
+ layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
my_data->logging_callback.pop_back();
}
@@ -5409,29 +5421,30 @@
return VK_ERROR_VALIDATION_FAILED;
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
- VkInstance instance,
- VkFlags msgFlags,
- const PFN_vkDbgMsgCallback pfnMsgCallback,
- void* pUserData,
- VkDebugReportCallbackLUNARG* pMsgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
+ VkInstance instance,
+ VkDebugReportCallbackCreateInfoLUNARG* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackLUNARG* pMsgCallback)
{
layer_data* my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
- VkResult res = my_data->instance_dispatch_table->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ VkResult res = pTable->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
if (VK_SUCCESS == res) {
- res = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ res = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback);
}
return res;
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
- VkInstance instance,
- VkDebugReportCallbackLUNARG msgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
+ VkInstance instance,
+ VkDebugReportCallbackLUNARG msgCallback,
+ const VkAllocationCallbacks* pAllocator)
{
layer_data* my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
- VkResult res = my_data->instance_dispatch_table->DbgDestroyMsgCallback(instance, msgCallback);
- layer_destroy_msg_callback(my_data->report_data, msgCallback);
- return res;
+ VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+ pTable->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
+ layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
}
VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDbgMarkerBegin(VkCommandBuffer commandBuffer, const char* pMarker)
diff --git a/layers/image.cpp b/layers/image.cpp
index e489286..cde964a 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -84,39 +84,49 @@
FILE *log_output = NULL;
const char* option_str = getLayerOption("ImageLogFilename");
log_output = getLayerLogOutput(option_str, "Image");
- layer_create_msg_callback(data->report_data, report_flags, log_callback, (void *) log_output, &callback);
+ VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+ memset(&dbgInfo, 0, sizeof(dbgInfo));
+ dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgInfo.pfnCallback = log_callback;
+ dbgInfo.pUserData = log_output;
+ dbgInfo.flags = report_flags;
+ layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator, &callback);
data->logging_callback.push_back(callback);
}
if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
- layer_create_msg_callback(data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+ VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+ memset(&dbgInfo, 0, sizeof(dbgInfo));
+ dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgInfo.pfnCallback = win32_debug_output_msg;
+ dbgInfo.flags = report_flags;
+ layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator, &callback);
data->logging_callback.push_back(callback);
}
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
- VkInstance instance,
- VkFlags msgFlags,
- const PFN_vkDbgMsgCallback pfnMsgCallback,
- void* pUserData,
- VkDebugReportCallbackLUNARG* pMsgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
+ VkInstance instance,
+ VkDebugReportCallbackCreateInfoLUNARG* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackLUNARG* pMsgCallback)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
- VkResult res = my_data->instance_dispatch_table->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ VkResult res = my_data->instance_dispatch_table->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
if (res == VK_SUCCESS) {
- res = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ res = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback);
}
return res;
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
- VkInstance instance,
- VkDebugReportCallbackLUNARG msgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
+ VkInstance instance,
+ VkDebugReportCallbackLUNARG msgCallback,
+ const VkAllocationCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
- VkResult res = my_data->instance_dispatch_table->DbgDestroyMsgCallback(instance, msgCallback);
- layer_destroy_msg_callback(my_data->report_data, msgCallback);
- return res;
+ my_data->instance_dispatch_table->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
+ layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
@@ -145,7 +155,7 @@
// Clean up logging callback, if any
while (my_data->logging_callback.size() > 0) {
VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
- layer_destroy_msg_callback(my_data->report_data, callback);
+ layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
my_data->logging_callback.pop_back();
}
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index bd65bcb..62a78ba 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1010,12 +1010,24 @@
{
option_str = getLayerOption("MemTrackerLogFilename");
log_output = getLayerLogOutput(option_str, "MemTracker");
- layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &callback);
+ VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+ memset(&dbgInfo, 0, sizeof(dbgInfo));
+ dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgInfo.pfnCallback = log_callback;
+ dbgInfo.pUserData = log_output;
+ dbgInfo.flags = report_flags;
+ layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback);
my_data->logging_callback.push_back(callback);
}
if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
- layer_create_msg_callback(my_data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+ VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+ memset(&dbgInfo, 0, sizeof(dbgInfo));
+ dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgInfo.pfnCallback = win32_debug_output_msg;
+ dbgInfo.pUserData = log_output;
+ dbgInfo.flags = report_flags;
+ layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback);
my_data->logging_callback.push_back(callback);
}
@@ -1043,7 +1055,7 @@
// Clean up logging callback, if any
while (my_data->logging_callback.size() > 0) {
VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
- layer_destroy_msg_callback(my_data->report_data, callback);
+ layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
my_data->logging_callback.pop_back();
}
@@ -2561,32 +2573,30 @@
my_data->device_dispatch_table->CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
- VkInstance instance,
- VkFlags msgFlags,
- const PFN_vkDbgMsgCallback pfnMsgCallback,
- void *pUserData,
- VkDebugReportCallbackLUNARG *pMsgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
+ VkInstance instance,
+ VkDebugReportCallbackCreateInfoLUNARG* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackLUNARG* pMsgCallback)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
- VkResult res = pTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ VkResult res = pTable->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
if (res == VK_SUCCESS) {
- res = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ res = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback);
}
return res;
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
- VkInstance instance,
- VkDebugReportCallbackLUNARG msgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
+ VkInstance instance,
+ VkDebugReportCallbackLUNARG msgCallback,
+ const VkAllocationCallbacks* pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
- VkResult res = pTable->DbgDestroyMsgCallback(instance, msgCallback);
- layer_destroy_msg_callback(my_data->report_data, msgCallback);
-
- return res;
+ pTable->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
+ layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
diff --git a/layers/object_track.h b/layers/object_track.h
index 1410151..08f36c7 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -425,7 +425,13 @@
{
option_str = getLayerOption("ObjectTrackerLogFilename");
log_output = getLayerLogOutput(option_str, "ObjectTracker");
- layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &(my_data->logging_callback));
+ VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+ memset(&dbgInfo, 0, sizeof(dbgInfo));
+ dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgInfo.pfnCallback = log_callback;
+ dbgInfo.pUserData = log_output;
+ dbgInfo.flags = report_flags;
+ layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &my_data->logging_callback);
}
if (!objLockInitialized)
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 42068a9..0514bf1 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -96,46 +96,58 @@
FILE *log_output = NULL;
const char* option_str = getLayerOption("ParamCheckerLogFilename");
log_output = getLayerLogOutput(option_str, "ParamChecker");
- layer_create_msg_callback(data->report_data, report_flags, log_callback, (void *) log_output, &callback);
+ VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;
+ memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
+ dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgCreateInfo.flags = report_flags;
+ dbgCreateInfo.pfnCallback = log_callback;
+ dbgCreateInfo.pUserData = log_output;
+
+ layer_create_msg_callback(data->report_data, &dbgCreateInfo, pAllocator, &callback);
data->logging_callback.push_back(callback);
}
if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
- layer_create_msg_callback(data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+ VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;
+ memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
+ dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgCreateInfo.flags = report_flags;
+ dbgCreateInfo.pfnCallback = win32_debug_output_msg;
+ dbgCreateInfo.pUserData = NULL;
+
+ layer_create_msg_callback(data->report_data, &dbgCreateInfo, pAllocator, &callback);
data->logging_callback.push_back(callback);
}
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
VkInstance instance,
- VkFlags msgFlags,
- const PFN_vkDbgMsgCallback pfnMsgCallback,
- void* pUserData,
+ VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo,
+ const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackLUNARG* pMsgCallback)
{
VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
- VkResult result = pTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ VkResult result = pTable->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
if (result == VK_SUCCESS)
{
layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
- result = layer_create_msg_callback(data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ result = layer_create_msg_callback(data->report_data, pCreateInfo, pAllocator, pMsgCallback);
}
return result;
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
VkInstance instance,
- VkDebugReportCallbackLUNARG msgCallback)
+ VkDebugReportCallbackLUNARG msgCallback,
+ const VkAllocationCallbacks *pAllocator)
{
VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
- VkResult result = pTable->DbgDestroyMsgCallback(instance, msgCallback);
+ pTable->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
- layer_destroy_msg_callback(data->report_data, msgCallback);
-
- return result;
+ layer_destroy_msg_callback(data->report_data, msgCallback, pAllocator);
}
static const VkLayerProperties pc_global_layers[] = {
@@ -1760,7 +1772,7 @@
layer_data *my_data = get_my_data_ptr(key, layer_data_map);
while (my_data->logging_callback.size() > 0) {
VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
- layer_destroy_msg_callback(my_data->report_data, callback);
+ layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
my_data->logging_callback.pop_back();
}
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 4c41928..2b8ed24 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -126,13 +126,26 @@
// Turn on logging, since it was requested:
option_str = getLayerOption("SwapchainLogFilename");
log_output = getLayerLogOutput(option_str, "Swapchain");
- layer_create_msg_callback(my_data->report_data, report_flags,
- log_callback, (void *) log_output,
+ VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+ memset(&dbgInfo, 0, sizeof(dbgInfo));
+ dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgInfo.pfnCallback = log_callback;
+ dbgInfo.pUserData = log_output;
+ dbgInfo.flags = report_flags;
+ layer_create_msg_callback(my_data->report_data,
+ &dbgInfo,
+ pAllocator,
&callback);
my_data->logging_callback.push_back(callback);
}
if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
- layer_create_msg_callback(my_data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+ VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+ memset(&dbgInfo, 0, sizeof(dbgInfo));
+ dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgInfo.pfnCallback = win32_debug_output_msg;
+ dbgInfo.pUserData = log_output;
+ dbgInfo.flags = report_flags;
+ layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback);
my_data->logging_callback.push_back(callback);
}
}
@@ -210,7 +223,7 @@
// Clean up logging callback, if any
while (my_data->logging_callback.size() > 0) {
VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
- layer_destroy_msg_callback(my_data->report_data, callback);
+ layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
my_data->logging_callback.pop_back();
}
layer_debug_report_destroy_instance(my_data->report_data);
@@ -1113,22 +1126,21 @@
return NULL;
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(VkInstance instance, VkFlags msgFlags, const PFN_vkDbgMsgCallback pfnMsgCallback, void* pUserData, VkDebugReportCallbackLUNARG* pMsgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(VkInstance instance, VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackLUNARG* pMsgCallback)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
- VkResult result = my_data->instance_dispatch_table->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ VkResult result = my_data->instance_dispatch_table->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
if (VK_SUCCESS == result) {
- result = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ result = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback);
}
return result;
}
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(VkInstance instance, VkDebugReportCallbackLUNARG msgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(VkInstance instance, VkDebugReportCallbackLUNARG msgCallback, const VkAllocationCallbacks *pAllocator)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
- VkResult result = my_data->instance_dispatch_table->DbgDestroyMsgCallback(instance, msgCallback);
- layer_destroy_msg_callback(my_data->report_data, msgCallback);
- return result;
+ my_data->instance_dispatch_table->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
+ layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
}
VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char* funcName)
diff --git a/layers/vk_layer_config.cpp b/layers/vk_layer_config.cpp
index 6d09a18..4ca7b2c 100755
--- a/layers/vk_layer_config.cpp
+++ b/layers/vk_layer_config.cpp
@@ -121,9 +121,9 @@
return log_output;
}
-uint32_t getLayerOptionFlags(const char *_option, uint32_t optionDefault)
+VkDebugReportFlagsLUNARG getLayerOptionFlags(const char *_option, uint32_t optionDefault)
{
- uint32_t flags = optionDefault;
+ VkDebugReportFlagsLUNARG flags = optionDefault;
const char *option = (g_configFileObj.getOption(_option));
/* parse comma-separated options */
diff --git a/layers/vk_layer_config.h b/layers/vk_layer_config.h
index c1fa1e1..167aaf6 100644
--- a/layers/vk_layer_config.h
+++ b/layers/vk_layer_config.h
@@ -32,7 +32,7 @@
const char *getLayerOption(const char *_option);
FILE* getLayerLogOutput(const char *_option, const char *layerName);
-uint32_t getLayerOptionFlags(const char *_option, uint32_t optionDefault);
+VkDebugReportFlagsLUNARG getLayerOptionFlags(const char *_option, uint32_t optionDefault);
bool getLayerOptionEnum(const char *_option, uint32_t *optionDefault);
void setLayerOption(const char *_option, const char *_val);
diff --git a/layers/vk_layer_logging.h b/layers/vk_layer_logging.h
index b603da8..325b3f0 100644
--- a/layers/vk_layer_logging.h
+++ b/layers/vk_layer_logging.h
@@ -88,8 +88,8 @@
debug_report_data *debug_data;
PFN_vkGetInstanceProcAddr gpa = table->GetInstanceProcAddr;
- table->DbgCreateMsgCallback = (PFN_vkDbgCreateMsgCallback) gpa(inst, "vkDbgCreateMsgCallback");
- table->DbgDestroyMsgCallback = (PFN_vkDbgDestroyMsgCallback) gpa(inst, "vkDbgDestroyMsgCallback");
+ table->CreateDebugReportCallbackLUNARG = (PFN_vkCreateDebugReportCallbackLUNARG) gpa(inst, "vkCreateDebugReportCallbackLUNARG");
+ table->DestroyDebugReportCallbackLUNARG = (PFN_vkDestroyDebugReportCallbackLUNARG) gpa(inst, "vkDestroyDebugReportCallbackLUNARG");
debug_data = (debug_report_data *) malloc(sizeof(debug_report_data));
if (!debug_data) return NULL;
@@ -148,31 +148,31 @@
}
static inline VkResult layer_create_msg_callback(
- debug_report_data *debug_data,
- VkFlags msgFlags,
- const PFN_vkDbgMsgCallback pfnMsgCallback,
- void *pUserData,
- VkDebugReportCallbackLUNARG *pMsgCallback)
+ debug_report_data *debug_data,
+ VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo,
+ const VkAllocationCallbacks *pAllocator,
+ VkDebugReportCallbackLUNARG *pCallback)
{
+ /* TODO: Use app allocator */
VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode*)malloc(sizeof(VkLayerDbgFunctionNode));
if (!pNewDbgFuncNode)
return VK_ERROR_OUT_OF_HOST_MEMORY;
// Handle of 0 is logging_callback so use allocated Node address as unique handle
- if (!(*pMsgCallback))
- *pMsgCallback = (VkDebugReportCallbackLUNARG) pNewDbgFuncNode;
- pNewDbgFuncNode->msgCallback = *pMsgCallback;
- pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
- pNewDbgFuncNode->msgFlags = msgFlags;
- pNewDbgFuncNode->pUserData = pUserData;
+ if (!(*pCallback))
+ *pCallback = (VkDebugReportCallbackLUNARG) pNewDbgFuncNode;
+ pNewDbgFuncNode->msgCallback = *pCallback;
+ pNewDbgFuncNode->pfnMsgCallback = pCreateInfo->pfnCallback;
+ pNewDbgFuncNode->msgFlags = pCreateInfo->flags;
+ pNewDbgFuncNode->pUserData = pCreateInfo->pUserData;
pNewDbgFuncNode->pNext = debug_data->g_pDbgFunctionHead;
debug_data->g_pDbgFunctionHead = pNewDbgFuncNode;
- debug_data->active_flags |= msgFlags;
+ debug_data->active_flags |= pCreateInfo->flags;
debug_report_log_msg(
debug_data, VK_DEBUG_REPORT_DEBUG_BIT,
- VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) *pMsgCallback,
+ VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) *pCallback,
0, DEBUG_REPORT_CALLBACK_REF,
"DebugReport",
"Added callback");
@@ -181,7 +181,8 @@
static inline void layer_destroy_msg_callback(
debug_report_data *debug_data,
- VkDebugReportCallbackLUNARG msg_callback)
+ VkDebugReportCallbackLUNARG callback,
+ const VkAllocationCallbacks *pAllocator)
{
VkLayerDbgFunctionNode *pTrav = debug_data->g_pDbgFunctionHead;
VkLayerDbgFunctionNode *pPrev = pTrav;
@@ -189,7 +190,7 @@
debug_data->active_flags = 0;
while (pTrav) {
- if (pTrav->msgCallback == msg_callback) {
+ if (pTrav->msgCallback == callback) {
matched = true;
pPrev->pNext = pTrav->pNext;
if (debug_data->g_pDbgFunctionHead == pTrav) {
@@ -208,6 +209,7 @@
pPrev = pTrav;
pTrav = pTrav->pNext;
if (matched) {
+ /* TODO: Use pAllocator */
free(pPrev);
}
}
@@ -221,11 +223,11 @@
return NULL;
}
- if (!strcmp(funcName, "vkDbgCreateMsgCallback")) {
- return (PFN_vkVoidFunction) vkDbgCreateMsgCallback;
+ if (!strcmp(funcName, "vkCreateDebugReportCallbackLUNARG")) {
+ return (PFN_vkVoidFunction) vkCreateDebugReportCallbackLUNARG;
}
- if (!strcmp(funcName, "vkDbgDestroyMsgCallback")) {
- return (PFN_vkVoidFunction) vkDbgDestroyMsgCallback;
+ if (!strcmp(funcName, "vkDestroyDebugReportCallbackLUNARG")) {
+ return (PFN_vkVoidFunction) vkDestroyDebugReportCallbackLUNARG;
}
return NULL;
@@ -294,7 +296,7 @@
static inline VKAPI_ATTR VkBool32 VKAPI_CALL log_callback(
VkFlags msgFlags,
- VkDebugReportObjectTypeLUNARG objType,
+ VkDebugReportObjectTypeLUNARG objType,
uint64_t srcObject,
size_t location,
int32_t msgCode,
@@ -315,7 +317,7 @@
static inline VKAPI_ATTR VkBool32 VKAPI_CALL win32_debug_output_msg(
VkFlags msgFlags,
- VkDebugReportObjectTypeLUNARG objType,
+ VkDebugReportObjectTypeLUNARG objType,
uint64_t srcObject,
size_t location,
int32_t msgCode,
diff --git a/layers/vk_layer_settings.txt b/layers/vk_layer_settings.txt
index 1aee14f..5634c9b 100644
--- a/layers/vk_layer_settings.txt
+++ b/layers/vk_layer_settings.txt
@@ -14,7 +14,7 @@
# VK_DBG_LAYER_ACTION_LOG_MSG - Log a txt message to stdout or to a log file
# specified via the <LayerName>LogFilename setting (see below)
# VK_DBG_LAYER_ACTION_CALLBACK - Call user defined callback function(s) that
-# have been registered via the vkDbgCreateMsgCallback() extension. Since
+# have been registered via the VK_EXT_LUNARG_debug_report extension. Since
# app must register callback, this is a NOOP for the settings file.
# VK_DBG_LAYER_ACTION_BREAK - Trigger a breakpoint.
#
diff --git a/loader/debug_report.c b/loader/debug_report.c
index b7057e6..f6b3a31 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -65,12 +65,11 @@
}
}
-static VKAPI_ATTR VkResult VKAPI_CALL debug_report_DbgCreateMsgCallback(
+static VKAPI_ATTR VkResult VKAPI_CALL debug_report_CreateDebugReportCallback(
VkInstance instance,
- VkFlags msgFlags,
- const PFN_vkDbgMsgCallback pfnMsgCallback,
- void* pUserData,
- VkDebugReportCallbackLUNARG* pMsgCallback)
+ VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo,
+ VkAllocationCallbacks *pAllocator,
+ VkDebugReportCallbackLUNARG* pCallback)
{
VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *) loader_heap_alloc((struct loader_instance *)instance, sizeof(VkLayerDbgFunctionNode), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!pNewDbgFuncNode)
@@ -78,12 +77,12 @@
struct loader_instance *inst = loader_get_instance(instance);
loader_platform_thread_lock_mutex(&loader_lock);
- VkResult result = inst->disp->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ VkResult result = inst->disp->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pCallback);
if (result == VK_SUCCESS) {
- pNewDbgFuncNode->msgCallback = *pMsgCallback;
- pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
- pNewDbgFuncNode->msgFlags = msgFlags;
- pNewDbgFuncNode->pUserData = pUserData;
+ pNewDbgFuncNode->msgCallback = *pCallback;
+ pNewDbgFuncNode->pfnMsgCallback = pCreateInfo->pfnCallback;
+ pNewDbgFuncNode->msgFlags = pCreateInfo->flags;
+ pNewDbgFuncNode->pUserData = pCreateInfo->pUserData;
pNewDbgFuncNode->pNext = inst->DbgFunctionHead;
inst->DbgFunctionHead = pNewDbgFuncNode;
} else {
@@ -93,19 +92,20 @@
return result;
}
-static VKAPI_ATTR VkResult VKAPI_CALL debug_report_DbgDestroyMsgCallback(
+static VKAPI_ATTR VkResult VKAPI_CALL debug_report_DestroyDebugReportCallback(
VkInstance instance,
- VkDebugReportCallbackLUNARG msg_callback)
+ VkDebugReportCallbackLUNARG callback,
+ VkAllocationCallbacks *pAllocator)
{
struct loader_instance *inst = loader_get_instance(instance);
loader_platform_thread_lock_mutex(&loader_lock);
VkLayerDbgFunctionNode *pTrav = inst->DbgFunctionHead;
VkLayerDbgFunctionNode *pPrev = pTrav;
- VkResult result = inst->disp->DbgDestroyMsgCallback(instance, msg_callback);
+ VkResult result = inst->disp->DestroyDebugReportCallbackLUNARG(instance, callback, pAllocator);
while (pTrav) {
- if (pTrav->msgCallback == msg_callback) {
+ if (pTrav->msgCallback == callback) {
pPrev->pNext = pTrav->pNext;
if (inst->DbgFunctionHead == pTrav)
inst->DbgFunctionHead = pTrav->pNext;
@@ -123,15 +123,14 @@
/*
* This is the instance chain terminator function
- * for DbgCreateMsgCallback
+ * for CreateDebugReportCallback
*/
-VKAPI_ATTR VkResult VKAPI_CALL loader_DbgCreateMsgCallback(
- VkInstance instance,
- VkFlags msgFlags,
- const PFN_vkDbgMsgCallback pfnMsgCallback,
- void* pUserData,
- VkDebugReportCallbackLUNARG* pMsgCallback)
+VKAPI_ATTR VkResult VKAPI_CALL loader_CreateDebugReportCallback(
+ VkInstance instance,
+ VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo,
+ const VkAllocationCallbacks *pAllocator,
+ VkDebugReportCallbackLUNARG *pCallback)
{
VkDebugReportCallbackLUNARG *icd_info;
const struct loader_icd *icd;
@@ -151,16 +150,15 @@
storage_idx = 0;
for (icd = inst->icds; icd; icd = icd->next) {
- if (!icd->DbgCreateMsgCallback) {
+ if (!icd->CreateDebugReportCallbackLUNARG) {
continue;
}
- res = icd->DbgCreateMsgCallback(
- icd->instance,
- msgFlags,
- pfnMsgCallback,
- pUserData,
- &icd_info[storage_idx]);
+ res = icd->CreateDebugReportCallbackLUNARG(
+ icd->instance,
+ pCreateInfo,
+ pAllocator,
+ &icd_info[storage_idx]);
if (res != VK_SUCCESS) {
break;
@@ -173,9 +171,10 @@
storage_idx = 0;
for (icd = inst->icds; icd; icd = icd->next) {
if (icd_info[storage_idx]) {
- icd->DbgDestroyMsgCallback(
+ icd->DestroyDebugReportCallbackLUNARG(
icd->instance,
- icd_info[storage_idx]);
+ icd_info[storage_idx],
+ pAllocator);
}
storage_idx++;
}
@@ -183,18 +182,17 @@
return res;
}
- *(VkDebugReportCallbackLUNARG **)pMsgCallback = icd_info;
+ *(VkDebugReportCallbackLUNARG **)pCallback = icd_info;
return VK_SUCCESS;
}
/*
* This is the instance chain terminator function
- * for DbgDestroyMsgCallback
+ * for DestroyDebugReportCallback
*/
-VKAPI_ATTR VkResult VKAPI_CALL loader_DbgDestroyMsgCallback(
- VkInstance instance,
- VkDebugReportCallbackLUNARG msgCallback)
+VKAPI_ATTR VkResult VKAPI_CALL loader_DestroyDebugReportCallback(VkInstance instance,
+ VkDebugReportCallbackLUNARG callback, const VkAllocationCallbacks *pAllocator)
{
uint32_t storage_idx;
VkDebugReportCallbackLUNARG *icd_info;
@@ -207,13 +205,14 @@
break;
}
- icd_info = *(VkDebugReportCallbackLUNARG **) &msgCallback;
+ icd_info = *(VkDebugReportCallbackLUNARG **) &callback;
storage_idx = 0;
for (icd = inst->icds; icd; icd = icd->next) {
if (icd_info[storage_idx]) {
- icd->DbgDestroyMsgCallback(
+ icd->DestroyDebugReportCallbackLUNARG(
icd->instance,
- icd_info[storage_idx]);
+ icd_info[storage_idx],
+ pAllocator);
}
storage_idx++;
}
@@ -229,12 +228,12 @@
// so always return the entry points if name matches and it's enabled
*addr = NULL;
- if (!strcmp("vkDbgCreateMsgCallback", name)) {
- *addr = ptr_instance->debug_report_enabled ? (void *) debug_report_DbgCreateMsgCallback : NULL;
+ if (!strcmp("vkCreateDebugReportCallbackLUNARG", name)) {
+ *addr = ptr_instance->debug_report_enabled ? (void *) debug_report_CreateDebugReportCallback : NULL;
return true;
}
- if (!strcmp("vkDbgDestroyMsgCallback", name)) {
- *addr = ptr_instance->debug_report_enabled ? (void *) debug_report_DbgDestroyMsgCallback : NULL;
+ if (!strcmp("vkDestroyDebugReportCallbackLUNARG", name)) {
+ *addr = ptr_instance->debug_report_enabled ? (void *) debug_report_DestroyDebugReportCallback : NULL;
return true;
}
return false;
diff --git a/loader/debug_report.h b/loader/debug_report.h
index a6107a7..8210021 100644
--- a/loader/debug_report.h
+++ b/loader/debug_report.h
@@ -102,13 +102,13 @@
const char* name,
void **addr);
-VKAPI_ATTR VkResult VKAPI_CALL loader_DbgCreateMsgCallback(
- VkInstance instance,
- VkFlags msgFlags,
- const PFN_vkDbgMsgCallback pfnMsgCallback,
- void* pUserData,
- VkDebugReportCallbackLUNARG* pMsgCallback);
+VKAPI_ATTR VkResult VKAPI_CALL loader_CreateDebugReportCallback(
+ VkInstance instance,
+ VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo,
+ const VkAllocationCallbacks *pAllocator,
+ VkDebugReportCallbackLUNARG *pCallback);
-VKAPI_ATTR VkResult VKAPI_CALL loader_DbgDestroyMsgCallback(
- VkInstance instance,
- VkDebugReportCallbackLUNARG msgCallback);
+VKAPI_ATTR VkResult VKAPI_CALL loader_DestroyDebugReportCallback(
+ VkInstance instance,
+ VkDebugReportCallbackLUNARG callback,
+ const VkAllocationCallbacks *pAllocator);
diff --git a/loader/loader.c b/loader/loader.c
index 5673be4..6e37f06 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -114,8 +114,8 @@
.GetPhysicalDeviceSurfaceCapabilitiesKHR = loader_GetPhysicalDeviceSurfaceCapabilitiesKHR,
.GetPhysicalDeviceSurfaceFormatsKHR = loader_GetPhysicalDeviceSurfaceFormatsKHR,
.GetPhysicalDeviceSurfacePresentModesKHR = loader_GetPhysicalDeviceSurfacePresentModesKHR,
- .DbgCreateMsgCallback = loader_DbgCreateMsgCallback,
- .DbgDestroyMsgCallback = loader_DbgDestroyMsgCallback,
+ .CreateDebugReportCallbackLUNARG = loader_CreateDebugReportCallback,
+ .DestroyDebugReportCallbackLUNARG = loader_DestroyDebugReportCallback,
#ifdef VK_USE_PLATFORM_MIR_KHR
.CreateMirSurfaceKHR = loader_CreateMirSurfaceKHR,
.GetPhysicalDeviceMirPresentationSupportKHR = loader_GetPhysicalDeviceMirPresentationSupportKHR,
@@ -1341,8 +1341,8 @@
LOOKUP_GIPA(GetPhysicalDeviceQueueFamilyProperties, true);
LOOKUP_GIPA(EnumerateDeviceExtensionProperties, true);
LOOKUP_GIPA(GetPhysicalDeviceSparseImageFormatProperties, true);
- LOOKUP_GIPA(DbgCreateMsgCallback, false);
- LOOKUP_GIPA(DbgDestroyMsgCallback, false);
+ LOOKUP_GIPA(CreateDebugReportCallbackLUNARG, false);
+ LOOKUP_GIPA(DestroyDebugReportCallbackLUNARG, false);
LOOKUP_GIPA(GetPhysicalDeviceSurfaceSupportKHR, false);
LOOKUP_GIPA(GetPhysicalDeviceSurfaceCapabilitiesKHR, false);
LOOKUP_GIPA(GetPhysicalDeviceSurfaceFormatsKHR, false);
diff --git a/loader/loader.h b/loader/loader.h
index 2b44de3..0c0c94a 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -188,8 +188,8 @@
PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
- PFN_vkDbgCreateMsgCallback DbgCreateMsgCallback;
- PFN_vkDbgDestroyMsgCallback DbgDestroyMsgCallback;
+ PFN_vkCreateDebugReportCallbackLUNARG CreateDebugReportCallbackLUNARG;
+ PFN_vkDestroyDebugReportCallbackLUNARG DestroyDebugReportCallbackLUNARG;
PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
diff --git a/loader/table_ops.h b/loader/table_ops.h
index ed9f8d6..7cbb51c 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -468,9 +468,9 @@
PFN_vkGetInstanceProcAddr gpa,
VkInstance inst)
{
- table->DbgCreateMsgCallback = (PFN_vkDbgCreateMsgCallback) gpa(inst, "vkDbgCreateMsgCallback");
- table->DbgDestroyMsgCallback = (PFN_vkDbgDestroyMsgCallback) gpa(inst, "vkDbgDestroyMsgCallback");
table->DestroySurfaceKHR = (PFN_vkDestroySurfaceKHR) gpa(inst, "vkDestroySurfaceKHR");
+ table->CreateDebugReportCallbackLUNARG = (PFN_vkCreateDebugReportCallbackLUNARG) gpa(inst, "vkCreateDebugReportCallbackLUNARG");
+ table->DestroyDebugReportCallbackLUNARG = (PFN_vkDestroyDebugReportCallbackLUNARG) gpa(inst, "vkDestroyDebugReportCallbackLUNARG");
table->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(inst, "vkGetPhysicalDeviceSurfaceSupportKHR");
table->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) gpa(inst, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
table->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) gpa(inst, "vkGetPhysicalDeviceSurfaceFormatsKHR");
@@ -571,10 +571,10 @@
if (!strcmp(name, "GetPhysicalDeviceXlibPresentationSupportKHR"))
return (void *) table->GetPhysicalDeviceXlibPresentationSupportKHR;
#endif
- if (!strcmp(name, "DbgCreateMsgCallback"))
- return (void *) table->DbgCreateMsgCallback;
- if (!strcmp(name, "DbgDestroyMsgCallback"))
- return (void *) table->DbgDestroyMsgCallback;
+ if (!strcmp(name, "CreateDebugReportCallbackLUNARG"))
+ return (void *) table->CreateDebugReportCallbackLUNARG;
+ if (!strcmp(name, "DestroyDebugReportCallbackLUNARG"))
+ return (void *) table->DestroyDebugReportCallbackLUNARG;
return NULL;
}
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index c0a824e..9333819 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -47,8 +47,8 @@
m_depth_clear_color( 1.0 ),
m_stencil_clear_color( 0 ),
m_depthStencil( NULL ),
- m_dbgCreateMsgCallback( VK_NULL_HANDLE ),
- m_dbgDestroyMsgCallback( VK_NULL_HANDLE ),
+ m_CreateDebugReportCallback( VK_NULL_HANDLE ),
+ m_DestroyDebugReportCallback( VK_NULL_HANDLE ),
m_globalMsgCallback( VK_NULL_HANDLE ),
m_devMsgCallback( VK_NULL_HANDLE )
{
@@ -86,7 +86,7 @@
std::vector<const char *> device_layer_names,
std::vector<const char *> instance_extension_names,
std::vector<const char *> device_extension_names,
- PFN_vkDbgMsgCallback dbgFunction,
+ PFN_vkDebugReportCallbackLUNARG dbgFunction,
void *userData)
{
VkInstanceCreateInfo instInfo = {};
@@ -113,18 +113,24 @@
ASSERT_VK_SUCCESS(err);
ASSERT_GE(this->gpu_count, (uint32_t) 1) << "No GPU available";
if (dbgFunction) {
- m_dbgCreateMsgCallback = (PFN_vkDbgCreateMsgCallback) vkGetInstanceProcAddr(this->inst, "vkDbgCreateMsgCallback");
- ASSERT_NE(m_dbgCreateMsgCallback, (PFN_vkDbgCreateMsgCallback) NULL) << "Did not get function pointer for DbgCreateMsgCallback";
- if (m_dbgCreateMsgCallback) {
- err = m_dbgCreateMsgCallback(this->inst,
- VK_DEBUG_REPORT_ERROR_BIT | VK_DEBUG_REPORT_WARN_BIT | VK_DEBUG_REPORT_PERF_WARN_BIT,
- dbgFunction,
- userData,
+ m_CreateDebugReportCallback = (PFN_vkCreateDebugReportCallbackLUNARG) vkGetInstanceProcAddr(this->inst, "vkCreateDebugReportCallbackLUNARG");
+ ASSERT_NE(m_CreateDebugReportCallback, (PFN_vkCreateDebugReportCallbackLUNARG) NULL) << "Did not get function pointer for CreateDebugReportCallback";
+ if (m_CreateDebugReportCallback) {
+ VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;
+ memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
+ dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgCreateInfo.flags = VK_DEBUG_REPORT_ERROR_BIT | VK_DEBUG_REPORT_WARN_BIT | VK_DEBUG_REPORT_PERF_WARN_BIT;
+ dbgCreateInfo.pfnCallback = dbgFunction;
+ dbgCreateInfo.pUserData = userData;
+
+ err = m_CreateDebugReportCallback(this->inst,
+ &dbgCreateInfo,
+ NULL,
&m_globalMsgCallback);
ASSERT_VK_SUCCESS(err);
- m_dbgDestroyMsgCallback = (PFN_vkDbgDestroyMsgCallback) vkGetInstanceProcAddr(this->inst, "vkDbgDestroyMsgCallback");
- ASSERT_NE(m_dbgDestroyMsgCallback, (PFN_vkDbgDestroyMsgCallback) NULL) << "Did not get function pointer for DbgDestroyMsgCallback";
+ m_DestroyDebugReportCallback = (PFN_vkDestroyDebugReportCallbackLUNARG) vkGetInstanceProcAddr(this->inst, "vkDestroyDebugReportCallbackLUNARG");
+ ASSERT_NE(m_DestroyDebugReportCallback, (PFN_vkDestroyDebugReportCallbackLUNARG) NULL) << "Did not get function pointer for DestroyDebugReportCallback";
}
}
@@ -133,11 +139,16 @@
/* Now register callback on device */
if (0) {
- if (m_dbgCreateMsgCallback) {
- err = m_dbgCreateMsgCallback(this->inst,
- VK_DEBUG_REPORT_ERROR_BIT | VK_DEBUG_REPORT_WARN_BIT,
- dbgFunction,
- userData,
+ if (m_CreateDebugReportCallback) {
+ VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+ memset(&dbgInfo, 0, sizeof(dbgInfo));
+ dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+ dbgInfo.pfnCallback = dbgFunction;
+ dbgInfo.pUserData = userData;
+ dbgInfo.flags = VK_DEBUG_REPORT_ERROR_BIT | VK_DEBUG_REPORT_WARN_BIT;
+ err = m_CreateDebugReportCallback(this->inst,
+ &dbgInfo,
+ NULL,
&m_devMsgCallback);
ASSERT_VK_SUCCESS(err);
}
@@ -155,8 +166,8 @@
if (m_framebuffer) vkDestroyFramebuffer(device(), m_framebuffer, NULL);
if (m_renderPass) vkDestroyRenderPass(device(), m_renderPass, NULL);
- if (m_globalMsgCallback) m_dbgDestroyMsgCallback(this->inst, m_globalMsgCallback);
- if (m_devMsgCallback) m_dbgDestroyMsgCallback(this->inst, m_devMsgCallback);
+ if (m_globalMsgCallback) m_DestroyDebugReportCallback(this->inst, m_globalMsgCallback, NULL);
+ if (m_devMsgCallback) m_DestroyDebugReportCallback(this->inst, m_devMsgCallback, NULL);
while (!m_renderTargets.empty()) {
vkDestroyImageView(device(), m_renderTargets.back()->targetView(m_render_target_fmt), NULL);
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index 85682ca..f5b3bf7 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -99,7 +99,7 @@
std::vector<const char *> device_layer_names,
std::vector<const char *> instance_extension_names,
std::vector<const char *> device_extension_names,
- PFN_vkDbgMsgCallback=NULL,
+ PFN_vkDebugReportCallbackLUNARG=NULL,
void *userData=NULL);
void ShutdownFramework();
@@ -140,8 +140,8 @@
float m_depth_clear_color;
uint32_t m_stencil_clear_color;
VkDepthStencilObj *m_depthStencil;
- PFN_vkDbgCreateMsgCallback m_dbgCreateMsgCallback;
- PFN_vkDbgDestroyMsgCallback m_dbgDestroyMsgCallback;
+ PFN_vkCreateDebugReportCallbackLUNARG m_CreateDebugReportCallback;
+ PFN_vkDestroyDebugReportCallbackLUNARG m_DestroyDebugReportCallback;
VkDebugReportCallbackLUNARG m_globalMsgCallback;
VkDebugReportCallbackLUNARG m_devMsgCallback;
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 43bd11c..7eaf327 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -227,22 +227,28 @@
def _gen_create_msg_callback(self):
r_body = []
r_body.append('%s' % self.lineinfo.get())
- r_body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(VkInstance instance, VkFlags msgFlags, const PFN_vkDbgMsgCallback pfnMsgCallback, void* pUserData, VkDebugReportCallbackLUNARG* pMsgCallback)')
+ r_body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(VkInstance instance,')
+ r_body.append(' VkDebugReportCallbackCreateInfoLUNARG* pCreateInfo,')
+ r_body.append(' const VkAllocationCallbacks* pAllocator,')
+ r_body.append(' VkDebugReportCallbackLUNARG* pCallback)')
r_body.append('{')
# Switch to this code section for the new per-instance storage and debug callbacks
if self.layer_name == 'ObjectTracker' or self.layer_name == 'Threading':
r_body.append(' VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(%s_instance_table_map, instance);' % self.layer_name )
- r_body.append(' VkResult result = pInstanceTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);')
+ r_body.append(' VkResult result = pInstanceTable->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pCallback);')
r_body.append(' if (VK_SUCCESS == result) {')
r_body.append(' layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
- r_body.append(' result = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);')
+ r_body.append(' result = layer_create_msg_callback(my_data->report_data,')
+ r_body.append(' pCreateInfo,')
+ r_body.append(' pAllocator,')
+ r_body.append(' pCallback);')
r_body.append(' }')
r_body.append(' return result;')
else:
- r_body.append(' VkResult result = instance_dispatch_table(instance)->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);')
+ r_body.append(' VkResult result = instance_dispatch_table(instance)->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pCallback);')
r_body.append(' if (VK_SUCCESS == result) {')
r_body.append(' layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
- r_body.append(' result = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);')
+ r_body.append(' result = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pCallback);')
r_body.append(' }')
r_body.append(' return result;')
r_body.append('}')
@@ -251,20 +257,16 @@
def _gen_destroy_msg_callback(self):
r_body = []
r_body.append('%s' % self.lineinfo.get())
- r_body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(VkInstance instance, VkDebugReportCallbackLUNARG msgCallback)')
+ r_body.append('VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(VkInstance instance, VkDebugReportCallbackLUNARG msgCallback, const VkAllocationCallbacks *pAllocator)')
r_body.append('{')
# Switch to this code section for the new per-instance storage and debug callbacks
if self.layer_name == 'ObjectTracker' or self.layer_name == 'Threading':
r_body.append(' VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(%s_instance_table_map, instance);' % self.layer_name )
- r_body.append(' VkResult result = pInstanceTable->DbgDestroyMsgCallback(instance, msgCallback);')
- r_body.append(' layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
- r_body.append(' layer_destroy_msg_callback(my_data->report_data, msgCallback);')
- r_body.append(' return result;')
else:
- r_body.append(' VkResult result = instance_dispatch_table(instance)->DbgDestroyMsgCallback(instance, msgCallback);')
- r_body.append(' layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
- r_body.append(' layer_destroy_msg_callback(my_data->report_data, msgCallback);')
- r_body.append(' return result;')
+ r_body.append(' VkLayerInstanceDispatchTable *pInstanceTable = instance_dispatch_table(instance);')
+ r_body.append(' pInstanceTable->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);')
+ r_body.append(' layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
+ r_body.append(' layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);')
r_body.append('}')
return "\n".join(r_body)
@@ -339,9 +341,9 @@
intercept = self.generate_intercept(proto, qual)
if intercept is None:
# fill in default intercept for certain entrypoints
- if 'DbgCreateMsgCallback' == proto.name:
+ if 'CreateDebugReportCallbackLUNARG' == proto.name:
intercept = self._gen_layer_dbg_create_msg_callback()
- elif 'DbgDestroyMsgCallback' == proto.name:
+ elif 'DestroyDebugReportCallbackLUNARG' == proto.name:
intercept = self._gen_layer_dbg_destroy_msg_callback()
elif 'CreateDevice' == proto.name:
funcs.append('/* CreateDevice HERE */')
@@ -626,8 +628,13 @@
func_body.append(' {')
func_body.append(' option_str = getLayerOption("%sLogFilename");' % self.layer_name)
func_body.append(' log_output = getLayerLogOutput(option_str,"%s");' % self.layer_name)
- func_body.append(' layer_create_msg_callback(my_data->report_data, report_flags,')
- func_body.append(' log_callback, (void *) log_output,')
+ func_body.append(' VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;')
+ func_body.append(' memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));')
+ func_body.append(' dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;')
+ func_body.append(' dbgCreateInfo.flags = report_flags;')
+ func_body.append(' dbgCreateInfo.pfnCallback = log_callback;')
+ func_body.append(' dbgCreateInfo.pUserData = NULL;')
+ func_body.append(' layer_create_msg_callback(my_data->report_data, &dbgCreateInfo, pAllocator,')
func_body.append(' &my_data->logging_callback);')
func_body.append(' }')
func_body.append('')
@@ -664,7 +671,14 @@
func_body.append(' {')
func_body.append(' strOpt = getLayerOption("%sLogFilename");' % self.layer_name)
func_body.append(' log_output = getLayerLogOutput(strOpt, "%s");' % self.layer_name)
- func_body.append(' layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &my_data->logging_callback);')
+ func_body.append(' VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;')
+ func_body.append(' memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));')
+ func_body.append(' dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;')
+ func_body.append(' dbgCreateInfo.flags = report_flags;')
+ func_body.append(' dbgCreateInfo.pfnCallback = log_callback;')
+ func_body.append(' dbgCreateInfo.pUserData = log_output;')
+ func_body.append(' layer_create_msg_callback(my_data->report_data, &dbgCreateInfo, pAllocator,')
+ func_body.append(' &my_data->logging_callback);')
func_body.append(' }')
func_body.append('')
if lockname is not None:
@@ -769,7 +783,7 @@
' // Clean up logging callback, if any\n'
' layer_data *my_data = get_my_data_ptr(key, layer_data_map);\n'
' if (my_data->logging_callback) {\n'
- ' layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback);\n'
+ ' layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback, pAllocator);\n'
' }\n\n'
' layer_debug_report_destroy_instance(my_data->report_data);\n'
' layer_data_map.erase(key);\n'
@@ -1493,7 +1507,7 @@
gedi_txt.append(' // Clean up logging callback, if any')
gedi_txt.append(' layer_data *my_data = get_my_data_ptr(key, layer_data_map);')
gedi_txt.append(' if (my_data->logging_callback) {')
- gedi_txt.append(' layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback);')
+ gedi_txt.append(' layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback, pAllocator);')
gedi_txt.append(' }')
gedi_txt.append('')
gedi_txt.append(' layer_debug_report_destroy_instance(mid(instance));')
@@ -1571,7 +1585,7 @@
return "\n".join(cbv_txt)
def generate_intercept(self, proto, qual):
- if proto.name in [ 'DbgCreateMsgCallback', 'EnumerateInstanceLayerProperties', 'EnumerateInstanceExtensionProperties','EnumerateDeviceLayerProperties', 'EnumerateDeviceExtensionProperties' ]:
+ if proto.name in [ 'CreateDebugReportCallbackLUNARG', 'EnumerateInstanceLayerProperties', 'EnumerateInstanceExtensionProperties','EnumerateDeviceLayerProperties', 'EnumerateDeviceExtensionProperties' ]:
# use default version
return None
@@ -1961,7 +1975,7 @@
return "\n".join(header_txt)
def generate_intercept(self, proto, qual):
- if proto.name in [ 'DbgCreateMsgCallback' ]:
+ if proto.name in [ 'CreateDebugReportCallbackLUNARG' ]:
# use default version
return None
decl = proto.c_func(prefix="vk", attr="VKAPI")
@@ -2055,7 +2069,7 @@
' // Clean up logging callback, if any\n'
' layer_data *my_data = get_my_data_ptr(key, layer_data_map);\n'
' if (my_data->logging_callback) {\n'
- ' layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback);\n'
+ ' layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback, pAllocator);\n'
' }\n'
'\n'
' layer_debug_report_destroy_instance(my_data->report_data);\n'
diff --git a/vk_helper.py b/vk_helper.py
index c875c2c..0d05083 100755
--- a/vk_helper.py
+++ b/vk_helper.py
@@ -1349,6 +1349,7 @@
def _generateSizeHelperHeaderC(self):
header = []
header.append('#include "vk_struct_size_helper.h"')
+ header.append('#include "vulkan/vk_lunarg_debug_report.h"')
header.append('#include <string.h>')
header.append('#include <assert.h>')
header.append('\n// Function definitions\n')
diff --git a/vulkan.py b/vulkan.py
index 1e32b2d..897688f 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -192,7 +192,7 @@
# VK core API
core = Extension(
name="VK_CORE",
- headers=["vulkan/vulkan.h", "vk_lunarg_debug_report.h"],
+ headers=["vulkan/vulkan.h", "vulkan/vk_lunarg_debug_report.h"],
objects=[
"VkInstance",
"VkPhysicalDevice",
@@ -1124,16 +1124,16 @@
"VkDebugReportCallbackLUNARG",
],
protos=[
- Proto("VkResult", "DbgCreateMsgCallback",
+ Proto("VkResult", "CreateDebugReportCallbackLUNARG",
[Param("VkInstance", "instance"),
- Param("VkFlags", "msgFlags"),
- Param("const PFN_vkDbgMsgCallback", "pfnMsgCallback"),
- Param("void*", "pUserData"),
- Param("VkDebugReportCallbackLUNARG*", "pMsgCallback")]),
+ Param("VkDebugReportCallbackCreateInfoLUNARG*", "pCreateInfo"),
+ Param("const VkAllocationCallbacks*", "pAllocator"),
+ Param("VkDebugReportCallbackLUNARG*", "pCallback")]),
- Proto("VkResult", "DbgDestroyMsgCallback",
+ Proto("VkResult", "DestroyDebugReportCallbackLUNARG",
[Param("VkInstance", "instance"),
- Param("VkDebugReportCallbackLUNARG", "msgCallback")]),
+ Param("VkDebugReportCallbackLUNARG", "callback"),
+ Param("const VkAllocationCallbacks*", "pAllocator")]),
],
)
lunarg_debug_marker = Extension(
@@ -1269,7 +1269,7 @@
# make them an extension and print
ext = Extension("VK_CORE",
- headers=["vulkan/vulkan.h", "vk_lunarg_debug_report.h"],
+ headers=["vulkan/vulkan.h", "vulkan/vk_lunarg_debug_report.h"],
objects=object_lines,
protos=protos)
print("core =", str(ext))