org.lwjgl.vulkan.KHRDisplay 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 java.nio.*;
import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.JNI.*;
import static org.lwjgl.system.MemoryUtil.*;
/** This extension provides the API to enumerate displays and available modes on a given device. */
public class KHRDisplay {
/** The extension specification version. */
public static final int VK_KHR_DISPLAY_SPEC_VERSION = 21;
/** The extension name. */
public static final String VK_KHR_DISPLAY_EXTENSION_NAME = "VK_KHR_display";
/**
* Extends {@code VkStructureType}.
*
* Enum values:
*
*
* - {@link #VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR}
* - {@link #VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR}
*
*/
public static final int
VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001;
/**
* VkDisplayPlaneAlphaFlagBitsKHR - alpha blending type
*
* Description
*
* These values are described as follows:
*
*
* - {@link #VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR}: The source image will be treated as opaque.
* - {@link #VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR}: A global alpha value must be specified that will be applied to all pixels in the source image.
* - {@link #VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR}: The alpha value will be determined by the alpha channel of the source image’s pixels. If the source format contains no alpha values, no blending will be applied. The source alpha values are not premultiplied into the source image’s other color channels.
* - {@link #VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR}: This is equivalent to {@link #VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR} except the source alpha values are assumed to be premultiplied into the source image’s other color channels.
*
*
* See Also
*
* {@code VkDisplayPlaneAlphaFlagsKHR}, {@link VkDisplaySurfaceCreateInfoKHR}
*/
public static final int
VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x1,
VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x2,
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x4,
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x8;
protected KHRDisplay() {
throw new UnsupportedOperationException();
}
static boolean isAvailable(VKCapabilities caps) {
return checkFunctions(
caps.vkGetPhysicalDeviceDisplayPropertiesKHR, caps.vkGetPhysicalDeviceDisplayPlanePropertiesKHR, caps.vkGetDisplayPlaneSupportedDisplaysKHR,
caps.vkGetDisplayModePropertiesKHR, caps.vkCreateDisplayModeKHR, caps.vkGetDisplayPlaneCapabilitiesKHR, caps.vkCreateDisplayPlaneSurfaceKHR
);
}
// --- [ vkGetPhysicalDeviceDisplayPropertiesKHR ] ---
/**
* Unsafe version of: {@link #vkGetPhysicalDeviceDisplayPropertiesKHR GetPhysicalDeviceDisplayPropertiesKHR}
*
* @param pPropertyCount a pointer to an integer related to the number of display devices available or queried, as described below.
*/
public static int nvkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, long pPropertyCount, long pProperties) {
long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceDisplayPropertiesKHR;
if ( CHECKS )
check(__functionAddress);
return callPPPI(__functionAddress, physicalDevice.address(), pPropertyCount, pProperties);
}
/**
* Query information about the available displays.
*
* C Specification
*
* Various functions are provided for enumerating the available display devices present on a Vulkan physical device. To query information about the available displays, call:
*
* VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
VkDisplayPropertiesKHR* pProperties);
*
* Description
*
* If {@code pProperties} is {@code NULL}, then the number of display devices available for {@code physicalDevice} is returned in {@code pPropertyCount}. Otherwise, {@code pPropertyCount} must point to a variable set by the user to the number of elements in the {@code pProperties} array, and on return the variable is overwritten with the number of structures actually written to {@code pProperties}. If the value of {@code pPropertyCount} is less than the number of display devices for {@code physicalDevice}, at most {@code pPropertyCount} structures will be written. If {@code pPropertyCount} is smaller than the number of display devices available for {@code physicalDevice}, {@link VK10#VK_INCOMPLETE INCOMPLETE} will be returned instead of {@link VK10#VK_SUCCESS SUCCESS} to indicate that not all the available values were returned.
*
* Valid Usage (Implicit)
*
*
* - {@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
* - {@code pPropertyCount} must be a pointer to a {@code uint32_t} value
* - If the value referenced by {@code pPropertyCount} is not 0, and {@code pProperties} is not {@code NULL}, {@code pProperties} must be a pointer to an array of {@code pPropertyCount} {@link VkDisplayPropertiesKHR} structures
*
*
* Return Codes
*
*
* - On success, this command returns
*
* - {@link VK10#VK_SUCCESS SUCCESS}
* - {@link VK10#VK_INCOMPLETE INCOMPLETE}
*
- 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 VkDisplayPropertiesKHR}
*
* @param physicalDevice a physical device.
* @param pPropertyCount a pointer to an integer related to the number of display devices available or queried, as described below.
* @param pProperties either {@code NULL} or a pointer to an array of {@link VkDisplayPropertiesKHR} structures.
*/
public static int vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, IntBuffer pPropertyCount, VkDisplayPropertiesKHR.Buffer pProperties) {
if ( CHECKS ) {
check(pPropertyCount, 1);
checkSafe(pProperties, pPropertyCount.get(pPropertyCount.position()));
}
return nvkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, memAddress(pPropertyCount), memAddressSafe(pProperties));
}
// --- [ vkGetPhysicalDeviceDisplayPlanePropertiesKHR ] ---
/**
* Unsafe version of: {@link #vkGetPhysicalDeviceDisplayPlanePropertiesKHR GetPhysicalDeviceDisplayPlanePropertiesKHR}
*
* @param pPropertyCount a pointer to an integer related to the number of display planes available or queried, as described below.
*/
public static int nvkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, long pPropertyCount, long pProperties) {
long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
if ( CHECKS )
check(__functionAddress);
return callPPPI(__functionAddress, physicalDevice.address(), pPropertyCount, pProperties);
}
/**
* Query the plane properties.
*
* C Specification
*
* Images are presented to individual planes on a display. Devices must support at least one plane on each display. Planes can be stacked and blended to composite multiple images on one display. Devices may support only a fixed stacking order and fixed mapping between planes and displays, or they may allow arbitrary application specified stacking orders and mappings between planes and displays. To query the properties of device display planes, call:
*
* VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
VkDisplayPlanePropertiesKHR* pProperties);
*
* Description
*
* If {@code pProperties} is {@code NULL}, then the number of display planes available for {@code physicalDevice} is returned in {@code pPropertyCount}. Otherwise, {@code pPropertyCount} must point to a variable set by the user to the number of elements in the {@code pProperties} array, and on return the variable is overwritten with the number of structures actually written to {@code pProperties}. If the value of {@code pPropertyCount} is less than the number of display planes for {@code physicalDevice}, at most {@code pPropertyCount} structures will be written.
*
* Valid Usage (Implicit)
*
*
* - {@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
* - {@code pPropertyCount} must be a pointer to a {@code uint32_t} value
* - If the value referenced by {@code pPropertyCount} is not 0, and {@code pProperties} is not {@code NULL}, {@code pProperties} must be a pointer to an array of {@code pPropertyCount} {@link VkDisplayPlanePropertiesKHR} structures
*
*
* Return Codes
*
*
* - On success, this command returns
*
* - {@link VK10#VK_SUCCESS SUCCESS}
* - {@link VK10#VK_INCOMPLETE INCOMPLETE}
*
- 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 VkDisplayPlanePropertiesKHR}
*
* @param physicalDevice a physical device.
* @param pPropertyCount a pointer to an integer related to the number of display planes available or queried, as described below.
* @param pProperties either {@code NULL} or a pointer to an array of {@link VkDisplayPlanePropertiesKHR} structures.
*/
public static int vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, IntBuffer pPropertyCount, VkDisplayPlanePropertiesKHR.Buffer pProperties) {
if ( CHECKS ) {
check(pPropertyCount, 1);
checkSafe(pProperties, pPropertyCount.get(pPropertyCount.position()));
}
return nvkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, memAddress(pPropertyCount), memAddressSafe(pProperties));
}
// --- [ vkGetDisplayPlaneSupportedDisplaysKHR ] ---
/**
* Unsafe version of: {@link #vkGetDisplayPlaneSupportedDisplaysKHR GetDisplayPlaneSupportedDisplaysKHR}
*
* @param pDisplayCount a pointer to an integer related to the number of display planes available or queried, as described below.
*/
public static int nvkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, int planeIndex, long pDisplayCount, long pDisplays) {
long __functionAddress = physicalDevice.getCapabilities().vkGetDisplayPlaneSupportedDisplaysKHR;
if ( CHECKS )
check(__functionAddress);
return callPPPI(__functionAddress, physicalDevice.address(), planeIndex, pDisplayCount, pDisplays);
}
/**
* Query the list of displays a plane supports.
*
* C Specification
*
* To determine which displays a plane is usable with, call
*
* VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
VkPhysicalDevice physicalDevice,
uint32_t planeIndex,
uint32_t* pDisplayCount,
VkDisplayKHR* pDisplays);
*
* Description
*
* If {@code pDisplays} is {@code NULL}, then the number of displays usable with the specified {@code planeIndex} for {@code physicalDevice} is returned in {@code pDisplayCount}. Otherwise, {@code pDisplayCount} must point to a variable set by the user to the number of elements in the {@code pDisplays} array, and on return the variable is overwritten with the number of structures actually written to {@code pDisplays}. If the value of {@code pDisplayCount} is less than the number of display planes for {@code physicalDevice}, at most {@code pDisplayCount} structures will be written. If {@code pDisplayCount} is smaller than the number of displays usable with the specified {@code planeIndex} for {@code physicalDevice}, {@link VK10#VK_INCOMPLETE INCOMPLETE} will be returned instead of {@link VK10#VK_SUCCESS SUCCESS} to indicate that not all the available values were returned.
*
* Valid Usage
*
*
* - {@code planeIndex} must be less than the number of display planes supported by the device as determined by calling {@link #vkGetPhysicalDeviceDisplayPlanePropertiesKHR GetPhysicalDeviceDisplayPlanePropertiesKHR}
*
*
* Valid Usage (Implicit)
*
*
* - {@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
* - {@code pDisplayCount} must be a pointer to a {@code uint32_t} value
* - If the value referenced by {@code pDisplayCount} is not 0, and {@code pDisplays} is not {@code NULL}, {@code pDisplays} must be a pointer to an array of {@code pDisplayCount} {@code VkDisplayKHR} handles
*
*
* Return Codes
*
*
* - On success, this command returns
*
* - {@link VK10#VK_SUCCESS SUCCESS}
* - {@link VK10#VK_INCOMPLETE INCOMPLETE}
*
- 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}
*
*
* @param physicalDevice a physical device.
* @param planeIndex the plane which the application wishes to use, and must be in the range [0, physical device plane count - 1].
* @param pDisplayCount a pointer to an integer related to the number of display planes available or queried, as described below.
* @param pDisplays either {@code NULL} or a pointer to an array of {@code VkDisplayKHR} structures.
*/
public static int vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, int planeIndex, IntBuffer pDisplayCount, LongBuffer pDisplays) {
if ( CHECKS ) {
check(pDisplayCount, 1);
checkSafe(pDisplays, pDisplayCount.get(pDisplayCount.position()));
}
return nvkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, memAddress(pDisplayCount), memAddressSafe(pDisplays));
}
// --- [ vkGetDisplayModePropertiesKHR ] ---
/**
* Unsafe version of: {@link #vkGetDisplayModePropertiesKHR GetDisplayModePropertiesKHR}
*
* @param pPropertyCount a pointer to an integer related to the number of display modes available or queried, as described below.
*/
public static int nvkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, long display, long pPropertyCount, long pProperties) {
long __functionAddress = physicalDevice.getCapabilities().vkGetDisplayModePropertiesKHR;
if ( CHECKS )
check(__functionAddress);
return callPJPPI(__functionAddress, physicalDevice.address(), display, pPropertyCount, pProperties);
}
/**
* Query the set of mode properties supported by the display.
*
* C Specification
*
* Each display has one or more supported modes associated with it by default. These built-in modes are queried by calling:
*
* VkResult vkGetDisplayModePropertiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
uint32_t* pPropertyCount,
VkDisplayModePropertiesKHR* pProperties);
*
* Description
*
* If {@code pProperties} is {@code NULL}, then the number of display modes available on the specified {@code display} for {@code physicalDevice} is returned in {@code pPropertyCount}. Otherwise, {@code pPropertyCount} must point to a variable set by the user to the number of elements in the {@code pProperties} array, and on return the variable is overwritten with the number of structures actually written to {@code pProperties}. If the value of {@code pPropertyCount} is less than the number of display modes for {@code physicalDevice}, at most {@code pPropertyCount} structures will be written. If {@code pPropertyCount} is smaller than the number of display modes available on the specified {@code display} for {@code physicalDevice}, {@link VK10#VK_INCOMPLETE INCOMPLETE} will be returned instead of {@link VK10#VK_SUCCESS SUCCESS} to indicate that not all the available values were returned.
*
* Valid Usage (Implicit)
*
*
* - {@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
* - {@code display} must be a valid {@code VkDisplayKHR} handle
* - {@code pPropertyCount} must be a pointer to a {@code uint32_t} value
* - If the value referenced by {@code pPropertyCount} is not 0, and {@code pProperties} is not {@code NULL}, {@code pProperties} must be a pointer to an array of {@code pPropertyCount} {@link VkDisplayModePropertiesKHR} structures
*
*
* Return Codes
*
*
* - On success, this command returns
*
* - {@link VK10#VK_SUCCESS SUCCESS}
* - {@link VK10#VK_INCOMPLETE INCOMPLETE}
*
- 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 VkDisplayModePropertiesKHR}
*
* @param physicalDevice the physical device associated with {@code display}.
* @param display the display to query.
* @param pPropertyCount a pointer to an integer related to the number of display modes available or queried, as described below.
* @param pProperties either {@code NULL} or a pointer to an array of {@link VkDisplayModePropertiesKHR} structures.
*/
public static int vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, long display, IntBuffer pPropertyCount, VkDisplayModePropertiesKHR.Buffer pProperties) {
if ( CHECKS ) {
check(pPropertyCount, 1);
checkSafe(pProperties, pPropertyCount.get(pPropertyCount.position()));
}
return nvkGetDisplayModePropertiesKHR(physicalDevice, display, memAddress(pPropertyCount), memAddressSafe(pProperties));
}
// --- [ vkCreateDisplayModeKHR ] ---
/** Unsafe version of: {@link #vkCreateDisplayModeKHR CreateDisplayModeKHR} */
public static int nvkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, long display, long pCreateInfo, long pAllocator, long pMode) {
long __functionAddress = physicalDevice.getCapabilities().vkCreateDisplayModeKHR;
if ( CHECKS ) {
check(__functionAddress);
if ( pAllocator != NULL ) VkAllocationCallbacks.validate(pAllocator);
}
return callPJPPPI(__functionAddress, physicalDevice.address(), display, pCreateInfo, pAllocator, pMode);
}
/**
* Create a display mode.
*
* C Specification
*
* Additional modes may also be created by calling:
*
* VkResult vkCreateDisplayModeKHR(
VkPhysicalDevice physicalDevice,
VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDisplayModeKHR* pMode);
*
* Valid Usage (Implicit)
*
*
* - {@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
* - {@code display} must be a valid {@code VkDisplayKHR} handle
* - {@code pCreateInfo} must be a pointer to a valid {@link VkDisplayModeCreateInfoKHR} structure
* - If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a pointer to a valid {@link VkAllocationCallbacks} structure
* - {@code pMode} must be a pointer to a {@code VkDisplayModeKHR} handle
*
*
* Host Synchronization
*
*
* - Host access to {@code display} 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}
* - {@link VK10#VK_ERROR_INITIALIZATION_FAILED ERROR_INITIALIZATION_FAILED}
*
*
* See Also
*
* {@link VkAllocationCallbacks}, {@link VkDisplayModeCreateInfoKHR}
*
* @param physicalDevice the physical device associated with {@code display}.
* @param display the display to create an additional mode for.
* @param pCreateInfo a {@link VkDisplayModeCreateInfoKHR} structure describing the new mode to create.
* @param pAllocator the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
* @param pMode returns the handle of the mode created.
*/
public static int vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, long display, VkDisplayModeCreateInfoKHR pCreateInfo, VkAllocationCallbacks pAllocator, LongBuffer pMode) {
if ( CHECKS )
check(pMode, 1);
return nvkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo.address(), memAddressSafe(pAllocator), memAddress(pMode));
}
// --- [ vkGetDisplayPlaneCapabilitiesKHR ] ---
/** Unsafe version of: {@link #vkGetDisplayPlaneCapabilitiesKHR GetDisplayPlaneCapabilitiesKHR} */
public static int nvkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, long mode, int planeIndex, long pCapabilities) {
long __functionAddress = physicalDevice.getCapabilities().vkGetDisplayPlaneCapabilitiesKHR;
if ( CHECKS )
check(__functionAddress);
return callPJPI(__functionAddress, physicalDevice.address(), mode, planeIndex, pCapabilities);
}
/**
* Query capabilities of a mode and plane combination.
*
* C Specification
*
* Applications that wish to present directly to a display must select which layer, or "plane" of the display they wish to target, and a mode to use with the display. Each display supports at least one plane. The capabilities of a given mode and plane combination are determined by calling:
*
* VkResult vkGetDisplayPlaneCapabilitiesKHR(
VkPhysicalDevice physicalDevice,
VkDisplayModeKHR mode,
uint32_t planeIndex,
VkDisplayPlaneCapabilitiesKHR* pCapabilities);
*
* Valid Usage (Implicit)
*
*
* - {@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
* - {@code mode} must be a valid {@code VkDisplayModeKHR} handle
* - {@code pCapabilities} must be a pointer to a {@link VkDisplayPlaneCapabilitiesKHR} structure
*
*
* Host Synchronization
*
*
* - Host access to {@code mode} 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 VkDisplayPlaneCapabilitiesKHR}
*
* @param physicalDevice the physical device associated with {@code display}
* @param mode the display mode the application intends to program when using the specified plane. Note this parameter also implicitly specifies a display.
* @param planeIndex the plane which the application intends to use with the display, and is less than the number of display planes supported by the device.
* @param pCapabilities a pointer to a {@link VkDisplayPlaneCapabilitiesKHR} structure in which the capabilities are returned.
*/
public static int vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, long mode, int planeIndex, VkDisplayPlaneCapabilitiesKHR pCapabilities) {
return nvkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities.address());
}
// --- [ vkCreateDisplayPlaneSurfaceKHR ] ---
/** Unsafe version of: {@link #vkCreateDisplayPlaneSurfaceKHR CreateDisplayPlaneSurfaceKHR} */
public static int nvkCreateDisplayPlaneSurfaceKHR(VkInstance instance, long pCreateInfo, long pAllocator, long pSurface) {
long __functionAddress = instance.getCapabilities().vkCreateDisplayPlaneSurfaceKHR;
if ( CHECKS ) {
check(__functionAddress);
if ( pAllocator != NULL ) VkAllocationCallbacks.validate(pAllocator);
}
return callPPPPI(__functionAddress, instance.address(), pCreateInfo, pAllocator, pSurface);
}
/**
* Create a {@code VkSurfaceKHR} structure representing a display plane and mode.
*
* C Specification
*
* A complete display configuration includes a mode, one or more display planes and any parameters describing their behavior, and parameters describing some aspects of the images associated with those planes. Display surfaces describe the configuration of a single plane within a complete display configuration. To create a {@code VkSurfaceKHR} structure for a display surface, call:
*
* VkResult vkCreateDisplayPlaneSurfaceKHR(
VkInstance instance,
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface);
*
* Valid Usage (Implicit)
*
*
* - {@code instance} must be a valid {@code VkInstance} handle
* - {@code pCreateInfo} must be a pointer to a valid {@link VkDisplaySurfaceCreateInfoKHR} structure
* - If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a pointer to a valid {@link VkAllocationCallbacks} structure
* - {@code pSurface} must be a pointer to a {@code VkSurfaceKHR} 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}
* - {@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
*
*
* See Also
*
* {@link VkAllocationCallbacks}, {@link VkDisplaySurfaceCreateInfoKHR}
*
* @param instance the instance corresponding to the physical device the targeted display is on.
* @param pCreateInfo a pointer to an instance of the {@link VkDisplaySurfaceCreateInfoKHR} structure specifying which mode, plane, and other parameters to use, as described below.
* @param pAllocator the allocator used for host memory allocated for the surface object when there is no more specific allocator available (see Memory Allocation).
* @param pSurface points to a {@code VkSurfaceKHR} handle in which the created surface is returned.
*/
public static int vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, VkDisplaySurfaceCreateInfoKHR pCreateInfo, VkAllocationCallbacks pAllocator, LongBuffer pSurface) {
if ( CHECKS )
check(pSurface, 1);
return nvkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo.address(), memAddressSafe(pAllocator), memAddress(pSurface));
}
/** Array version of: {@link #vkGetPhysicalDeviceDisplayPropertiesKHR GetPhysicalDeviceDisplayPropertiesKHR} */
public static int vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, int[] pPropertyCount, VkDisplayPropertiesKHR.Buffer pProperties) {
long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceDisplayPropertiesKHR;
if ( CHECKS ) {
check(__functionAddress);
check(pPropertyCount, 1);
checkSafe(pProperties, pPropertyCount[0]);
}
return callPPPI(__functionAddress, physicalDevice.address(), pPropertyCount, memAddressSafe(pProperties));
}
/** Array version of: {@link #vkGetPhysicalDeviceDisplayPlanePropertiesKHR GetPhysicalDeviceDisplayPlanePropertiesKHR} */
public static int vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, int[] pPropertyCount, VkDisplayPlanePropertiesKHR.Buffer pProperties) {
long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
if ( CHECKS ) {
check(__functionAddress);
check(pPropertyCount, 1);
checkSafe(pProperties, pPropertyCount[0]);
}
return callPPPI(__functionAddress, physicalDevice.address(), pPropertyCount, memAddressSafe(pProperties));
}
/** Array version of: {@link #vkGetDisplayPlaneSupportedDisplaysKHR GetDisplayPlaneSupportedDisplaysKHR} */
public static int vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, int planeIndex, int[] pDisplayCount, long[] pDisplays) {
long __functionAddress = physicalDevice.getCapabilities().vkGetDisplayPlaneSupportedDisplaysKHR;
if ( CHECKS ) {
check(__functionAddress);
check(pDisplayCount, 1);
checkSafe(pDisplays, pDisplayCount[0]);
}
return callPPPI(__functionAddress, physicalDevice.address(), planeIndex, pDisplayCount, pDisplays);
}
/** Array version of: {@link #vkGetDisplayModePropertiesKHR GetDisplayModePropertiesKHR} */
public static int vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, long display, int[] pPropertyCount, VkDisplayModePropertiesKHR.Buffer pProperties) {
long __functionAddress = physicalDevice.getCapabilities().vkGetDisplayModePropertiesKHR;
if ( CHECKS ) {
check(__functionAddress);
check(pPropertyCount, 1);
checkSafe(pProperties, pPropertyCount[0]);
}
return callPJPPI(__functionAddress, physicalDevice.address(), display, pPropertyCount, memAddressSafe(pProperties));
}
/** Array version of: {@link #vkCreateDisplayModeKHR CreateDisplayModeKHR} */
public static int vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, long display, VkDisplayModeCreateInfoKHR pCreateInfo, VkAllocationCallbacks pAllocator, long[] pMode) {
long __functionAddress = physicalDevice.getCapabilities().vkCreateDisplayModeKHR;
if ( CHECKS ) {
check(__functionAddress);
check(pMode, 1);
if ( pAllocator != null ) VkAllocationCallbacks.validate(pAllocator.address());
}
return callPJPPPI(__functionAddress, physicalDevice.address(), display, pCreateInfo.address(), memAddressSafe(pAllocator), pMode);
}
/** Array version of: {@link #vkCreateDisplayPlaneSurfaceKHR CreateDisplayPlaneSurfaceKHR} */
public static int vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, VkDisplaySurfaceCreateInfoKHR pCreateInfo, VkAllocationCallbacks pAllocator, long[] pSurface) {
long __functionAddress = instance.getCapabilities().vkCreateDisplayPlaneSurfaceKHR;
if ( CHECKS ) {
check(__functionAddress);
check(pSurface, 1);
if ( pAllocator != null ) VkAllocationCallbacks.validate(pAllocator.address());
}
return callPPPPI(__functionAddress, instance.address(), pCreateInfo.address(), memAddressSafe(pAllocator), pSurface);
}
}