org.lwjgl.vulkan.EXTDebugUtils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of lwjgl-vulkan Show documentation
Show all versions of lwjgl-vulkan Show documentation
A new generation graphics and compute API that provides high-efficiency, cross-platform access to modern GPUs used in a wide variety of devices from PCs and consoles to mobile phones and embedded platforms.
/*
* Copyright LWJGL. All rights reserved.
* License terms: https://www.lwjgl.org/license
* MACHINE GENERATED FILE, DO NOT EDIT
*/
package org.lwjgl.vulkan;
import javax.annotation.*;
import java.nio.*;
import org.lwjgl.system.*;
import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.JNI.*;
import static org.lwjgl.system.MemoryUtil.*;
/**
* Due to the nature of the Vulkan interface, there is very little error information available to the developer and application. By using the {@code VK_EXT_debug_utils} extension, developers can obtain more information. When combined with validation layers, even more detailed feedback on the application’s use of Vulkan will be provided.
*
* This extension provides the following capabilities:
*
*
* - The ability to create a debug messenger which will pass along debug messages to an application supplied callback.
* - The ability to identify specific Vulkan objects using a name or tag to improve tracking.
* - The ability to identify specific sections within a {@code VkQueue} or {@code VkCommandBuffer} using labels to aid organization and offline analysis in external tools.
*
*
* The main difference between this extension and {@link EXTDebugReport VK_EXT_debug_report} and {@link EXTDebugMarker VK_EXT_debug_marker} is that those extensions use {@code VkDebugReportObjectTypeEXT} to identify objects. This extension uses the core {@code VkObjectType} in place of {@code VkDebugReportObjectTypeEXT}. The primary reason for this move is that no future object type handle enumeration values will be added to {@code VkDebugReportObjectTypeEXT} since the creation of {@code VkObjectType}.
*
* In addition, this extension combines the functionality of both {@link EXTDebugReport VK_EXT_debug_report} and {@link EXTDebugMarker VK_EXT_debug_marker} by allowing object name and debug markers (now called labels) to be returned to the application’s callback function. This should assist in clarifying the details of a debug message including: what objects are involved and potentially which location within a {@code VkQueue} or {@code VkCommandBuffer} the message occurred.
*
* Examples
*
* Example 1
*
* {@code VK_EXT_debug_utils} allows an application to register multiple callbacks with any Vulkan component wishing to report debug information. Some callbacks may log the information to a file, others may cause a debug break point or other application defined behavior. An application can register callbacks even when no validation layers are enabled, but they will only be called for loader and, if implemented, driver events.
*
* To capture events that occur while creating or destroying an instance an application can link a {@link VkDebugUtilsMessengerCreateInfoEXT} structure to the {@code pNext} element of the {@link VkInstanceCreateInfo} structure given to {@link VK10#vkCreateInstance CreateInstance}.
*
* Example uses: Create three callback objects. One will log errors and warnings to the debug console using Windows {@code OutputDebugString}. The second will cause the debugger to break at that callback when an error happens and the third will log warnings to stdout.
*
*
* extern VkInstance instance;
* VkResult res;
* VkDebugUtilsMessengerEXT cb1, cb2, cb3;
*
* // Must call extension functions through a function pointer:
* PFN_vkCreateDebugUtilsMessengerEXT pfnCreateDebugUtilsMessengerEXT = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
* PFN_vkDestroyDebugUtilsMessengerEXT pfnDestroyDebugUtilsMessengerEXT = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
*
* VkDebugUtilsMessengerCreateInfoEXT callback1 = {
* VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, // sType
* NULL, // pNext
* 0, // flags
* VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | // messageSeverity
* VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
* VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | // messageType
* VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
* myOutputDebugString, // pfnUserCallback
* NULL // pUserData
* };
* res = pfnCreateDebugUtilsMessengerEXT(instance, &callback1, NULL, &cb1);
* if (res != VK_SUCCESS) {
* // Do error handling for VK_ERROR_OUT_OF_MEMORY
* }
*
* callback1.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
* callback1.pfnUserCallback = myDebugBreak;
* callback1.pUserData = NULL;
* res = pfnCreateDebugUtilsMessengerEXT(instance, &callback1, NULL, &cb2);
* if (res != VK_SUCCESS) {
* // Do error handling for VK_ERROR_OUT_OF_MEMORY
* }
*
* VkDebugUtilsMessengerCreateInfoEXT callback3 = {
* VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, // sType
* NULL, // pNext
* 0, // flags
* VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT, // messageSeverity
* VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | // messageType
* VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
* mystdOutLogger, // pfnUserCallback
* NULL // pUserData
* };
* res = pfnCreateDebugUtilsMessengerEXT(instance, &callback3, NULL, &cb3);
* if (res != VK_SUCCESS) {
* // Do error handling for VK_ERROR_OUT_OF_MEMORY
* }
*
* ...
*
* // Remove callbacks when cleaning up
* pfnDestroyDebugUtilsMessengerEXT(instance, cb1, NULL);
* pfnDestroyDebugUtilsMessengerEXT(instance, cb2, NULL);
* pfnDestroyDebugUtilsMessengerEXT(instance, cb3, NULL);
*
* Example 2
*
* Associate a name with an image, for easier debugging in external tools or with validation layers that can print a friendly name when referring to objects in error messages.
*
*
* extern VkInstance instance;
* extern VkDevice device;
* extern VkImage image;
*
* // Must call extension functions through a function pointer:
* PFN_vkSetDebugUtilsObjectNameEXT pfnSetDebugUtilsObjectNameEXT = (PFN_vkSetDebugUtilsObjectNameEXT)vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT");
*
* // Set a name on the image
* const VkDebugUtilsObjectNameInfoEXT imageNameInfo =
* {
* VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, // sType
* NULL, // pNext
* VK_OBJECT_TYPE_IMAGE, // objectType
* (uint64_t)image, // objectHandle
* "Brick Diffuse Texture", // pObjectName
* };
*
* pfnSetDebugUtilsObjectNameEXT(device, &imageNameInfo);
*
* // A subsequent error might print:
* // Image 'Brick Diffuse Texture' (0xc0dec0dedeadbeef) is used in a
* // command buffer with no memory bound to it.
*
* Example 3
*
* Annotating regions of a workload with naming information so that offline analysis tools can display a more usable visualization of the commands submitted.
*
*
* extern VkInstance instance;
* extern VkCommandBuffer commandBuffer;
*
* // Must call extension functions through a function pointer:
* PFN_vkQueueBeginDebugUtilsLabelEXT pfnQueueBeginDebugUtilsLabelEXT = (PFN_vkQueueBeginDebugUtilsLabelEXT)vkGetInstanceProcAddr(instance, "vkQueueBeginDebugUtilsLabelEXT");
* PFN_vkQueueEndDebugUtilsLabelEXT pfnQueueEndDebugUtilsLabelEXT = (PFN_vkQueueEndDebugUtilsLabelEXT)vkGetInstanceProcAddr(instance, "vkQueueEndDebugUtilsLabelEXT");
* PFN_vkCmdBeginDebugUtilsLabelEXT pfnCmdBeginDebugUtilsLabelEXT = (PFN_vkCmdBeginDebugUtilsLabelEXT)vkGetInstanceProcAddr(instance, "vkCmdBeginDebugUtilsLabelEXT");
* PFN_vkCmdEndDebugUtilsLabelEXT pfnCmdEndDebugUtilsLabelEXT = (PFN_vkCmdEndDebugUtilsLabelEXT)vkGetInstanceProcAddr(instance, "vkCmdEndDebugUtilsLabelEXT");
* PFN_vkCmdInsertDebugUtilsLabelEXT pfnCmdInsertDebugUtilsLabelEXT = (PFN_vkCmdInsertDebugUtilsLabelEXT)vkGetInstanceProcAddr(instance, "vkCmdInsertDebugUtilsLabelEXT");
*
* // Describe the area being rendered
* const VkDebugUtilsLabelEXT houseLabel =
* {
* VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, // sType
* NULL, // pNext
* "Brick House", // pLabelName
* { 1.0f, 0.0f, 0.0f, 1.0f }, // color
* };
*
* // Start an annotated group of calls under the 'Brick House' name
* pfnCmdBeginDebugUtilsLabelEXT(commandBuffer, &houseLabel);
* {
* // A mutable structure for each part being rendered
* VkDebugUtilsLabelEXT housePartLabel =
* {
* VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, // sType
* NULL, // pNext
* NULL, // pLabelName
* { 0.0f, 0.0f, 0.0f, 0.0f }, // color
* };
*
* // Set the name and insert the marker
* housePartLabel.pLabelName = "Walls";
* pfnCmdInsertDebugUtilsLabelEXT(commandBuffer, &housePartLabel);
*
* // Insert the drawcall for the walls
* vkCmdDrawIndexed(commandBuffer, 1000, 1, 0, 0, 0);
*
* // Insert a recursive region for two sets of windows
* housePartLabel.pLabelName = "Windows";
* pfnCmdBeginDebugUtilsLabelEXT(commandBuffer, &housePartLabel);
* {
* vkCmdDrawIndexed(commandBuffer, 75, 6, 1000, 0, 0);
* vkCmdDrawIndexed(commandBuffer, 100, 2, 1450, 0, 0);
* }
* pfnCmdEndDebugUtilsLabelEXT(commandBuffer);
*
* housePartLabel.pLabelName = "Front Door";
* pfnCmdInsertDebugUtilsLabelEXT(commandBuffer, &housePartLabel);
*
* vkCmdDrawIndexed(commandBuffer, 350, 1, 1650, 0, 0);
*
* housePartLabel.pLabelName = "Roof";
* pfnCmdInsertDebugUtilsLabelEXT(commandBuffer, &housePartLabel);
*
* vkCmdDrawIndexed(commandBuffer, 500, 1, 2000, 0, 0);
* }
* // End the house annotation started above
* pfnCmdEndDebugUtilsLabelEXT(commandBuffer);
*
* // Do other work
*
* vkEndCommandBuffer(commandBuffer);
*
* // Describe the queue being used
* const VkDebugUtilsLabelEXT queueLabel =
* {
* VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, // sType
* NULL, // pNext
* "Main Render Work", // pLabelName
* { 0.0f, 1.0f, 0.0f, 1.0f }, // color
* };
*
* // Identify the queue label region
* pfnQueueBeginDebugUtilsLabelEXT(queue, &queueLabel);
*
* // Submit the work for the main render thread
* const VkCommandBuffer cmd_bufs[] = {commandBuffer};
* VkSubmitInfo submit_info = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
* .pNext = NULL,
* .waitSemaphoreCount = 0,
* .pWaitSemaphores = NULL,
* .pWaitDstStageMask = NULL,
* .commandBufferCount = 1,
* .pCommandBuffers = cmd_bufs,
* .signalSemaphoreCount = 0,
* .pSignalSemaphores = NULL};
* vkQueueSubmit(queue, 1, &submit_info, fence);
*
* // End the queue label region
* pfnQueueEndDebugUtilsLabelEXT(queue);
*
* VK_EXT_debug_utils
*
*
* - Name String
* - {@code VK_EXT_debug_utils}
* - Extension Type
* - Instance extension
* - Registered Extension Number
* - 129
* - Revision
* - 2
* - Extension and Version Dependencies
*
* - Requires Vulkan 1.0
*
- Special Use
*
* - Debugging tools
*
- Contact
*
* - Mark Young marky-lunarg
*
*
* Other Extension Metadata
*
*
* - Last Modified Date
* - 2020-04-03
* - Revision
* - 2
* - IP Status
* - No known IP claims.
* - Dependencies
*
* - This extension is written against version 1.0 of the Vulkan API.
* - Requires {@code VkObjectType}
*
- Contributors
*
* - Mark Young, LunarG
* - Baldur Karlsson
* - Ian Elliott, Google
* - Courtney Goeltzenleuchter, Google
* - Karl Schultz, LunarG
* - Mark Lobodzinski, LunarG
* - Mike Schuchardt, LunarG
* - Jaakko Konttinen, AMD
* - Dan Ginsburg, Valve Software
* - Rolando Olivares, Epic Games
* - Dan Baker, Oxide Games
* - Kyle Spagnoli, NVIDIA
* - Jon Ashburn, LunarG
* - Piers Daniell, NVIDIA
*
*/
public class EXTDebugUtils {
/** The extension specification version. */
public static final int VK_EXT_DEBUG_UTILS_SPEC_VERSION = 2;
/** The extension name. */
public static final String VK_EXT_DEBUG_UTILS_EXTENSION_NAME = "VK_EXT_debug_utils";
/**
* Extends {@code VkStructureType}.
*
* Enum values:
*
*
* - {@link #VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT}
* - {@link #VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT}
* - {@link #VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT}
* - {@link #VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT}
* - {@link #VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT}
*
*/
public static final int
VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000,
VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001,
VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002,
VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003,
VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004;
/** Extends {@code VkObjectType}. */
public static final int VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000;
/**
* VkDebugUtilsMessageSeverityFlagBitsEXT - Bitmask specifying which severities of events cause a debug messenger callback
*
* Description
*
*
* - {@link #VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT} specifies the most verbose output indicating all diagnostic messages from the Vulkan loader, layers, and drivers should be captured.
* - {@link #VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT} specifies an informational message such as resource details that may be handy when debugging an application.
* - {@link #VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT} specifies use of Vulkan that may expose an app bug. Such cases may not be immediately harmful, such as a fragment shader outputting to a location with no attachment. Other cases may point to behavior that is almost certainly bad when unintended such as using an image whose memory has not been filled. In general if you see a warning but you know that the behavior is intended/desired, then simply ignore the warning.
* - {@link #VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT} specifies that the application has violated a valid usage condition of the specification.
*
*
* Note
*
* The values of {@code VkDebugUtilsMessageSeverityFlagBitsEXT} are sorted based on severity. The higher the flag value, the more severe the message. This allows for simple boolean operation comparisons when looking at {@code VkDebugUtilsMessageSeverityFlagBitsEXT} values.
*
* For example:
*
*
* if (messageSeverity >= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
* // Do something for warnings and errors
* }
*
* In addition, space has been left between the enums to allow for later addition of new severities in between the existing values.
*
*
* See Also
*
* {@link #vkSubmitDebugUtilsMessageEXT SubmitDebugUtilsMessageEXT}
*/
public static final int
VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x1,
VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x10,
VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x100,
VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x1000;
/**
* VkDebugUtilsMessageTypeFlagBitsEXT - Bitmask specifying which types of events cause a debug messenger callback
*
* Description
*
*
* - {@link #VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT} specifies that some general event has occurred. This is typically a non-specification, non-performance event.
* - {@link #VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT} specifies that something has occurred during validation against the Vulkan specification that may indicate invalid behavior.
* - {@link #VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT} specifies a potentially non-optimal use of Vulkan, e.g. using {@link VK10#vkCmdClearColorImage CmdClearColorImage} when setting {@link VkAttachmentDescription}{@code ::loadOp} to {@link VK10#VK_ATTACHMENT_LOAD_OP_CLEAR ATTACHMENT_LOAD_OP_CLEAR} would have worked.
*
*/
public static final int
VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x1,
VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x2,
VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x4;
protected EXTDebugUtils() {
throw new UnsupportedOperationException();
}
// --- [ vkSetDebugUtilsObjectNameEXT ] ---
/** Unsafe version of: {@link #vkSetDebugUtilsObjectNameEXT SetDebugUtilsObjectNameEXT} */
public static int nvkSetDebugUtilsObjectNameEXT(VkDevice device, long pNameInfo) {
long __functionAddress = device.getCapabilities().vkSetDebugUtilsObjectNameEXT;
if (CHECKS) {
check(__functionAddress);
}
return callPPI(device.address(), pNameInfo, __functionAddress);
}
/**
* Give a user-friendly name to an object.
*
* C Specification
*
*
* VkResult vkSetDebugUtilsObjectNameEXT(
* VkDevice device,
* const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
*
* Valid Usage
*
*
* - {@code pNameInfo→objectType} must not be {@link VK10#VK_OBJECT_TYPE_UNKNOWN OBJECT_TYPE_UNKNOWN}
* - {@code pNameInfo→objectHandle} must not be {@link VK10#VK_NULL_HANDLE NULL_HANDLE}
*
*
* Valid Usage (Implicit)
*
*
* - {@code device} must be a valid {@code VkDevice} handle
* - {@code pNameInfo} must be a valid pointer to a valid {@link VkDebugUtilsObjectNameInfoEXT} structure
*
*
* Host Synchronization
*
*
* - Host access to {@code pNameInfo→objectHandle} must be externally synchronized
*
*
* Return Codes
*
*
* - On success, this command returns
*
* - {@link VK10#VK_SUCCESS SUCCESS}
*
- On failure, this command returns
*
* - {@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
* - {@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
*
*
* See Also
*
* {@link VkDebugUtilsObjectNameInfoEXT}
*
* @param device the device that created the object.
* @param pNameInfo a pointer to a {@link VkDebugUtilsObjectNameInfoEXT} structure specifying parameters of the name to set on the object.
*/
@NativeType("VkResult")
public static int vkSetDebugUtilsObjectNameEXT(VkDevice device, @NativeType("VkDebugUtilsObjectNameInfoEXT const *") VkDebugUtilsObjectNameInfoEXT pNameInfo) {
return nvkSetDebugUtilsObjectNameEXT(device, pNameInfo.address());
}
// --- [ vkSetDebugUtilsObjectTagEXT ] ---
/** Unsafe version of: {@link #vkSetDebugUtilsObjectTagEXT SetDebugUtilsObjectTagEXT} */
public static int nvkSetDebugUtilsObjectTagEXT(VkDevice device, long pTagInfo) {
long __functionAddress = device.getCapabilities().vkSetDebugUtilsObjectTagEXT;
if (CHECKS) {
check(__functionAddress);
VkDebugUtilsObjectTagInfoEXT.validate(pTagInfo);
}
return callPPI(device.address(), pTagInfo, __functionAddress);
}
/**
* Attach arbitrary data to an object.
*
* C Specification
*
*
* VkResult vkSetDebugUtilsObjectTagEXT(
* VkDevice device,
* const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
*
* Valid Usage (Implicit)
*
*
* - {@code device} must be a valid {@code VkDevice} handle
* - {@code pTagInfo} must be a valid pointer to a valid {@link VkDebugUtilsObjectTagInfoEXT} structure
*
*
* Host Synchronization
*
*
* - Host access to {@code pTagInfo→objectHandle} must be externally synchronized
*
*
* Return Codes
*
*
* - On success, this command returns
*
* - {@link VK10#VK_SUCCESS SUCCESS}
*
- On failure, this command returns
*
* - {@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
* - {@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
*
*
* See Also
*
* {@link VkDebugUtilsObjectTagInfoEXT}
*
* @param device the device that created the object.
* @param pTagInfo a pointer to a {@link VkDebugUtilsObjectTagInfoEXT} structure specifying parameters of the tag to attach to the object.
*/
@NativeType("VkResult")
public static int vkSetDebugUtilsObjectTagEXT(VkDevice device, @NativeType("VkDebugUtilsObjectTagInfoEXT const *") VkDebugUtilsObjectTagInfoEXT pTagInfo) {
return nvkSetDebugUtilsObjectTagEXT(device, pTagInfo.address());
}
// --- [ vkQueueBeginDebugUtilsLabelEXT ] ---
/** Unsafe version of: {@link #vkQueueBeginDebugUtilsLabelEXT QueueBeginDebugUtilsLabelEXT} */
public static void nvkQueueBeginDebugUtilsLabelEXT(VkQueue queue, long pLabelInfo) {
long __functionAddress = queue.getCapabilities().vkQueueBeginDebugUtilsLabelEXT;
if (CHECKS) {
check(__functionAddress);
VkDebugUtilsLabelEXT.validate(pLabelInfo);
}
callPPV(queue.address(), pLabelInfo, __functionAddress);
}
/**
* Open a queue debug label region.
*
* C Specification
*
* A queue debug label region is opened by calling:
*
*
* void vkQueueBeginDebugUtilsLabelEXT(
* VkQueue queue,
* const VkDebugUtilsLabelEXT* pLabelInfo);
*
* Valid Usage (Implicit)
*
*
* - {@code queue} must be a valid {@code VkQueue} handle
* - {@code pLabelInfo} must be a valid pointer to a valid {@link VkDebugUtilsLabelEXT} structure
*
*
* Command Properties
*
*
* Command Buffer Levels Render Pass Scope Supported Queue Types - - Any
*
* See Also
*
* {@link VkDebugUtilsLabelEXT}
*
* @param queue the queue in which to start a debug label region.
* @param pLabelInfo a pointer to a {@link VkDebugUtilsLabelEXT} structure specifying parameters of the label region to open.
*/
public static void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, @NativeType("VkDebugUtilsLabelEXT const *") VkDebugUtilsLabelEXT pLabelInfo) {
nvkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo.address());
}
// --- [ vkQueueEndDebugUtilsLabelEXT ] ---
/**
* Close a queue debug label region.
*
* C Specification
*
* A queue debug label region is closed by calling:
*
*
* void vkQueueEndDebugUtilsLabelEXT(
* VkQueue queue);
*
* Description
*
* The calls to {@link #vkQueueBeginDebugUtilsLabelEXT QueueBeginDebugUtilsLabelEXT} and {@link #vkQueueEndDebugUtilsLabelEXT QueueEndDebugUtilsLabelEXT} must be matched and balanced.
*
* Valid Usage
*
*
* - There must be an outstanding {@code vkQueueBeginDebugUtilsLabelEXT} command prior to the {@code vkQueueEndDebugUtilsLabelEXT} on the queue
*
*
* Valid Usage (Implicit)
*
*
* - {@code queue} must be a valid {@code VkQueue} handle
*
*
* Command Properties
*
*
* Command Buffer Levels Render Pass Scope Supported Queue Types - - Any
*
* @param queue the queue in which a debug label region should be closed.
*/
public static void vkQueueEndDebugUtilsLabelEXT(VkQueue queue) {
long __functionAddress = queue.getCapabilities().vkQueueEndDebugUtilsLabelEXT;
if (CHECKS) {
check(__functionAddress);
}
callPV(queue.address(), __functionAddress);
}
// --- [ vkQueueInsertDebugUtilsLabelEXT ] ---
/** Unsafe version of: {@link #vkQueueInsertDebugUtilsLabelEXT QueueInsertDebugUtilsLabelEXT} */
public static void nvkQueueInsertDebugUtilsLabelEXT(VkQueue queue, long pLabelInfo) {
long __functionAddress = queue.getCapabilities().vkQueueInsertDebugUtilsLabelEXT;
if (CHECKS) {
check(__functionAddress);
VkDebugUtilsLabelEXT.validate(pLabelInfo);
}
callPPV(queue.address(), pLabelInfo, __functionAddress);
}
/**
* Insert a label into a queue.
*
* C Specification
*
* A single label can be inserted into a queue by calling:
*
*
* void vkQueueInsertDebugUtilsLabelEXT(
* VkQueue queue,
* const VkDebugUtilsLabelEXT* pLabelInfo);
*
* Valid Usage (Implicit)
*
*
* - {@code queue} must be a valid {@code VkQueue} handle
* - {@code pLabelInfo} must be a valid pointer to a valid {@link VkDebugUtilsLabelEXT} structure
*
*
* Command Properties
*
*
* Command Buffer Levels Render Pass Scope Supported Queue Types - - Any
*
* See Also
*
* {@link VkDebugUtilsLabelEXT}
*
* @param queue the queue into which a debug label will be inserted.
* @param pLabelInfo a pointer to a {@link VkDebugUtilsLabelEXT} structure specifying parameters of the label to insert.
*/
public static void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, @NativeType("VkDebugUtilsLabelEXT const *") VkDebugUtilsLabelEXT pLabelInfo) {
nvkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo.address());
}
// --- [ vkCmdBeginDebugUtilsLabelEXT ] ---
/** Unsafe version of: {@link #vkCmdBeginDebugUtilsLabelEXT CmdBeginDebugUtilsLabelEXT} */
public static void nvkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, long pLabelInfo) {
long __functionAddress = commandBuffer.getCapabilities().vkCmdBeginDebugUtilsLabelEXT;
if (CHECKS) {
check(__functionAddress);
VkDebugUtilsLabelEXT.validate(pLabelInfo);
}
callPPV(commandBuffer.address(), pLabelInfo, __functionAddress);
}
/**
* Open a command buffer debug label region.
*
* C Specification
*
* A command buffer debug label region can be opened by calling:
*
*
* void vkCmdBeginDebugUtilsLabelEXT(
* VkCommandBuffer commandBuffer,
* const VkDebugUtilsLabelEXT* pLabelInfo);
*
* Valid Usage (Implicit)
*
*
* - {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
* - {@code pLabelInfo} must be a valid pointer to a valid {@link VkDebugUtilsLabelEXT} structure
* - {@code commandBuffer} must be in the recording state
* - The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics, or compute operations
*
*
* Host Synchronization
*
*
* - Host access to {@code commandBuffer} must be externally synchronized
* - Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
*
*
* Command Properties
*
*
* Command Buffer Levels Render Pass Scope Supported Queue Types Primary Secondary Both Graphics Compute
*
* See Also
*
* {@link VkDebugUtilsLabelEXT}
*
* @param commandBuffer the command buffer into which the command is recorded.
* @param pLabelInfo a pointer to a {@link VkDebugUtilsLabelEXT} structure specifying parameters of the label region to open.
*/
public static void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, @NativeType("VkDebugUtilsLabelEXT const *") VkDebugUtilsLabelEXT pLabelInfo) {
nvkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo.address());
}
// --- [ vkCmdEndDebugUtilsLabelEXT ] ---
/**
* Close a command buffer label region.
*
* C Specification
*
* A command buffer label region can be closed by calling:
*
*
* void vkCmdEndDebugUtilsLabelEXT(
* VkCommandBuffer commandBuffer);
*
* Description
*
* An application may open a debug label region in one command buffer and close it in another, or otherwise split debug label regions across multiple command buffers or multiple queue submissions. When viewed from the linear series of submissions to a single queue, the calls to {@link #vkCmdBeginDebugUtilsLabelEXT CmdBeginDebugUtilsLabelEXT} and {@link #vkCmdEndDebugUtilsLabelEXT CmdEndDebugUtilsLabelEXT} must be matched and balanced.
*
* There can be problems reporting command buffer debug labels during the recording process because command buffers may be recorded out of sequence with the resulting execution order. Since the recording order may be different, a solitary command buffer may have an inconsistent view of the debug label regions by itself. Therefore, if an issue occurs during the recording of a command buffer, and the environment requires returning debug labels, the implementation may return only those labels it is aware of. This is true even if the implementation is aware of only the debug labels within the command buffer being actively recorded.
*
* Valid Usage
*
*
* - There must be an outstanding {@code vkCmdBeginDebugUtilsLabelEXT} command prior to the {@code vkCmdEndDebugUtilsLabelEXT} on the queue that {@code commandBuffer} is submitted to
* - If {@code commandBuffer} is a secondary command buffer, there must be an outstanding {@code vkCmdBeginDebugUtilsLabelEXT} command recorded to {@code commandBuffer} that has not previously been ended by a call to {@code vkCmdEndDebugUtilsLabelEXT}
*
*
* Valid Usage (Implicit)
*
*
* - {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
* - {@code commandBuffer} must be in the recording state
* - The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics, or compute operations
*
*
* Host Synchronization
*
*
* - Host access to {@code commandBuffer} must be externally synchronized
* - Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
*
*
* Command Properties
*
*
* Command Buffer Levels Render Pass Scope Supported Queue Types Primary Secondary Both Graphics Compute
*
* @param commandBuffer the command buffer into which the command is recorded.
*/
public static void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {
long __functionAddress = commandBuffer.getCapabilities().vkCmdEndDebugUtilsLabelEXT;
if (CHECKS) {
check(__functionAddress);
}
callPV(commandBuffer.address(), __functionAddress);
}
// --- [ vkCmdInsertDebugUtilsLabelEXT ] ---
/** Unsafe version of: {@link #vkCmdInsertDebugUtilsLabelEXT CmdInsertDebugUtilsLabelEXT} */
public static void nvkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, long pLabelInfo) {
long __functionAddress = commandBuffer.getCapabilities().vkCmdInsertDebugUtilsLabelEXT;
if (CHECKS) {
check(__functionAddress);
VkDebugUtilsLabelEXT.validate(pLabelInfo);
}
callPPV(commandBuffer.address(), pLabelInfo, __functionAddress);
}
/**
* Insert a label into a command buffer.
*
* C Specification
*
* A single debug label can be inserted into a command buffer by calling:
*
*
* void vkCmdInsertDebugUtilsLabelEXT(
* VkCommandBuffer commandBuffer,
* const VkDebugUtilsLabelEXT* pLabelInfo);
*
* Valid Usage (Implicit)
*
*
* - {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
* - {@code pLabelInfo} must be a valid pointer to a valid {@link VkDebugUtilsLabelEXT} structure
* - {@code commandBuffer} must be in the recording state
* - The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics, or compute operations
*
*
* Host Synchronization
*
*
* - Host access to {@code commandBuffer} must be externally synchronized
* - Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
*
*
* Command Properties
*
*
* Command Buffer Levels Render Pass Scope Supported Queue Types Primary Secondary Both Graphics Compute
*
* See Also
*
* {@link VkDebugUtilsLabelEXT}
*
* @param commandBuffer the command buffer into which the command is recorded.
*/
public static void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, @NativeType("VkDebugUtilsLabelEXT const *") VkDebugUtilsLabelEXT pLabelInfo) {
nvkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo.address());
}
// --- [ vkCreateDebugUtilsMessengerEXT ] ---
/** Unsafe version of: {@link #vkCreateDebugUtilsMessengerEXT CreateDebugUtilsMessengerEXT} */
public static int nvkCreateDebugUtilsMessengerEXT(VkInstance instance, long pCreateInfo, long pAllocator, long pMessenger) {
long __functionAddress = instance.getCapabilities().vkCreateDebugUtilsMessengerEXT;
if (CHECKS) {
check(__functionAddress);
VkDebugUtilsMessengerCreateInfoEXT.validate(pCreateInfo);
if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
}
return callPPPPI(instance.address(), pCreateInfo, pAllocator, pMessenger, __functionAddress);
}
/**
* Create a debug messenger object.
*
* C Specification
*
* A debug messenger triggers a debug callback with a debug message when an event of interest occurs. To create a debug messenger which will trigger a debug callback, call:
*
*
* VkResult vkCreateDebugUtilsMessengerEXT(
* VkInstance instance,
* const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
* const VkAllocationCallbacks* pAllocator,
* VkDebugUtilsMessengerEXT* pMessenger);
*
* Valid Usage (Implicit)
*
*
* - {@code instance} must be a valid {@code VkInstance} handle
* - {@code pCreateInfo} must be a valid pointer to a valid {@link VkDebugUtilsMessengerCreateInfoEXT} structure
* - If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
* - {@code pMessenger} must be a valid pointer to a {@code VkDebugUtilsMessengerEXT} handle
*
*
* Return Codes
*
*
* - On success, this command returns
*
* - {@link VK10#VK_SUCCESS SUCCESS}
*
- On failure, this command returns
*
* - {@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
*
*
* The application must ensure that {@link #vkCreateDebugUtilsMessengerEXT CreateDebugUtilsMessengerEXT} is not executed in parallel with any Vulkan command that is also called with {@code instance} or child of {@code instance} as the dispatchable argument.
*
* See Also
*
* {@link VkAllocationCallbacks}, {@link VkDebugUtilsMessengerCreateInfoEXT}
*
* @param instance the instance the messenger will be used with.
* @param pCreateInfo a pointer to a {@link VkDebugUtilsMessengerCreateInfoEXT} structure containing the callback pointer, as well as defining conditions under which this messenger will trigger the callback.
* @param pAllocator controls host memory allocation as described in the Memory Allocation chapter.
* @param pMessenger a pointer to a {@code VkDebugUtilsMessengerEXT} handle in which the created object is returned.
*/
@NativeType("VkResult")
public static int vkCreateDebugUtilsMessengerEXT(VkInstance instance, @NativeType("VkDebugUtilsMessengerCreateInfoEXT const *") VkDebugUtilsMessengerCreateInfoEXT pCreateInfo, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator, @NativeType("VkDebugUtilsMessengerEXT *") LongBuffer pMessenger) {
if (CHECKS) {
check(pMessenger, 1);
}
return nvkCreateDebugUtilsMessengerEXT(instance, pCreateInfo.address(), memAddressSafe(pAllocator), memAddress(pMessenger));
}
// --- [ vkDestroyDebugUtilsMessengerEXT ] ---
/** Unsafe version of: {@link #vkDestroyDebugUtilsMessengerEXT DestroyDebugUtilsMessengerEXT} */
public static void nvkDestroyDebugUtilsMessengerEXT(VkInstance instance, long messenger, long pAllocator) {
long __functionAddress = instance.getCapabilities().vkDestroyDebugUtilsMessengerEXT;
if (CHECKS) {
check(__functionAddress);
if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
}
callPJPV(instance.address(), messenger, pAllocator, __functionAddress);
}
/**
* Destroy a debug messenger object.
*
* C Specification
*
* To destroy a {@code VkDebugUtilsMessengerEXT} object, call:
*
*
* void vkDestroyDebugUtilsMessengerEXT(
* VkInstance instance,
* VkDebugUtilsMessengerEXT messenger,
* const VkAllocationCallbacks* pAllocator);
*
* Valid Usage
*
*
* - If {@link VkAllocationCallbacks} were provided when {@code messenger} was created, a compatible set of callbacks must be provided here
* - If no {@link VkAllocationCallbacks} were provided when {@code messenger} was created, {@code pAllocator} must be {@code NULL}
*
*
* Valid Usage (Implicit)
*
*
* - {@code instance} must be a valid {@code VkInstance} handle
* - If {@code messenger} is not {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, {@code messenger} must be a valid {@code VkDebugUtilsMessengerEXT} handle
* - If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
* - If {@code messenger} is a valid handle, it must have been created, allocated, or retrieved from {@code instance}
*
*
* Host Synchronization
*
*
* - Host access to {@code messenger} must be externally synchronized
*
*
* The application must ensure that {@link #vkDestroyDebugUtilsMessengerEXT DestroyDebugUtilsMessengerEXT} is not executed in parallel with any Vulkan command that is also called with {@code instance} or child of {@code instance} as the dispatchable argument.
*
* See Also
*
* {@link VkAllocationCallbacks}
*
* @param instance the instance where the callback was created.
* @param messenger the {@code VkDebugUtilsMessengerEXT} object to destroy. {@code messenger} is an externally synchronized object and must not be used on more than one thread at a time. This means that {@code vkDestroyDebugUtilsMessengerEXT} must not be called when a callback is active.
* @param pAllocator controls host memory allocation as described in the Memory Allocation chapter.
*/
public static void vkDestroyDebugUtilsMessengerEXT(VkInstance instance, @NativeType("VkDebugUtilsMessengerEXT") long messenger, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator) {
nvkDestroyDebugUtilsMessengerEXT(instance, messenger, memAddressSafe(pAllocator));
}
// --- [ vkSubmitDebugUtilsMessageEXT ] ---
/** Unsafe version of: {@link #vkSubmitDebugUtilsMessageEXT SubmitDebugUtilsMessageEXT} */
public static void nvkSubmitDebugUtilsMessageEXT(VkInstance instance, int messageSeverity, int messageTypes, long pCallbackData) {
long __functionAddress = instance.getCapabilities().vkSubmitDebugUtilsMessageEXT;
if (CHECKS) {
check(__functionAddress);
VkDebugUtilsMessengerCallbackDataEXT.validate(pCallbackData);
}
callPPV(instance.address(), messageSeverity, messageTypes, pCallbackData, __functionAddress);
}
/**
* Inject a message into a debug stream.
*
* C Specification
*
* There may be times that a user wishes to intentionally submit a debug message. To do this, call:
*
*
* void vkSubmitDebugUtilsMessageEXT(
* VkInstance instance,
* VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
* VkDebugUtilsMessageTypeFlagsEXT messageTypes,
* const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
*
* Description
*
* The call will propagate through the layers and generate callback(s) as indicated by the message’s flags. The parameters are passed on to the callback in addition to the {@code pUserData} value that was defined at the time the messenger was registered.
*
* Valid Usage
*
*
* - The {@code objectType} member of each element of {@code pCallbackData→pObjects} must not be {@link VK10#VK_OBJECT_TYPE_UNKNOWN OBJECT_TYPE_UNKNOWN}
*
*
* Valid Usage (Implicit)
*
*
* - {@code instance} must be a valid {@code VkInstance} handle
* - {@code messageSeverity} must be a valid {@code VkDebugUtilsMessageSeverityFlagBitsEXT} value
* - {@code messageTypes} must be a valid combination of {@code VkDebugUtilsMessageTypeFlagBitsEXT} values
* - {@code messageTypes} must not be 0
* - {@code pCallbackData} must be a valid pointer to a valid {@link VkDebugUtilsMessengerCallbackDataEXT} structure
*
*
* See Also
*
* {@link VkDebugUtilsMessengerCallbackDataEXT}
*
* @param instance the debug stream’s {@code VkInstance}.
* @param messageSeverity a {@code VkDebugUtilsMessageSeverityFlagBitsEXT} value specifying the severity of this event/message.
* @param messageTypes a bitmask of {@code VkDebugUtilsMessageTypeFlagBitsEXT} specifying which type of event(s) to identify with this message.
* @param pCallbackData contains all the callback related data in the {@link VkDebugUtilsMessengerCallbackDataEXT} structure.
*/
public static void vkSubmitDebugUtilsMessageEXT(VkInstance instance, @NativeType("VkDebugUtilsMessageSeverityFlagBitsEXT") int messageSeverity, @NativeType("VkDebugUtilsMessageTypeFlagsEXT") int messageTypes, @NativeType("VkDebugUtilsMessengerCallbackDataEXT const *") VkDebugUtilsMessengerCallbackDataEXT pCallbackData) {
nvkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData.address());
}
/** Array version of: {@link #vkCreateDebugUtilsMessengerEXT CreateDebugUtilsMessengerEXT} */
@NativeType("VkResult")
public static int vkCreateDebugUtilsMessengerEXT(VkInstance instance, @NativeType("VkDebugUtilsMessengerCreateInfoEXT const *") VkDebugUtilsMessengerCreateInfoEXT pCreateInfo, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator, @NativeType("VkDebugUtilsMessengerEXT *") long[] pMessenger) {
long __functionAddress = instance.getCapabilities().vkCreateDebugUtilsMessengerEXT;
if (CHECKS) {
check(__functionAddress);
check(pMessenger, 1);
VkDebugUtilsMessengerCreateInfoEXT.validate(pCreateInfo.address());
if (pAllocator != null) { VkAllocationCallbacks.validate(pAllocator.address()); }
}
return callPPPPI(instance.address(), pCreateInfo.address(), memAddressSafe(pAllocator), pMessenger, __functionAddress);
}
}