Package org.lwjgl.vulkan

Class KHRSwapchain

java.lang.Object
org.lwjgl.vulkan.KHRSwapchain
public class KHRSwapchain extends Object
The VK_KHR_swapchain extension is the device-level companion to the VK_KHR_surface extension. It introduces VkSwapchainKHR objects, which provide the ability to present rendering results to a surface.
Examples
Note

The example code for the VK_KHR_surface and VK_KHR_swapchain extensions was removed from the appendix after revision 1.0.29. This WSI example code was ported to the cube demo that is shipped with the official Khronos SDK, and is being kept up-to-date in that location (see: https://github.com/KhronosGroup/Vulkan-Tools/blob/main/cube/cube.c).

Name String
VK_KHR_swapchain
Extension Type
Device extension
Registered Extension Number
2
Revision
70
Extension and Version Dependencies
VK_KHR_surface
API Interactions
  • Interacts with VK_VERSION_1_1
Contact
Other Extension Metadata
Last Modified Date
2017-10-06
IP Status
No known IP claims.
Interactions and External Dependencies
  • Interacts with Vulkan 1.1
Contributors
  • Patrick Doane, Blizzard
  • Ian Elliott, LunarG
  • Jesse Hall, Google
  • Mathias Heyer, NVIDIA
  • James Jones, NVIDIA
  • David Mao, AMD
  • Norbert Nopper, Freescale
  • Alon Or-bach, Samsung
  • Daniel Rakos, AMD
  • Graham Sellers, AMD
  • Jeff Vigil, Qualcomm
  • Chia-I Wu, LunarG
  • Faith Ekstrand, Intel
  • Matthaeus G. Chajdas, AMD
  • Ray Smith, ARM

  • Field Details

  • Method Details

    • nvkCreateSwapchainKHR

      public static int nvkCreateSwapchainKHR(org.lwjgl.vulkan.VkDevice device, long pCreateInfo, long pAllocator, long pSwapchain)
      Unsafe version of: CreateSwapchainKHR

    • vkCreateSwapchainKHR

      public static int vkCreateSwapchainKHR(org.lwjgl.vulkan.VkDevice device, VkSwapchainCreateInfoKHR pCreateInfo, @Nullable VkAllocationCallbacks pAllocator, LongBuffer pSwapchain)
      Create a swapchain.
      C Specification

      To create a swapchain, call:

      
 VkResult vkCreateSwapchainKHR(
     VkDevice                                    device,
     const VkSwapchainCreateInfoKHR*             pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSwapchainKHR*                             pSwapchain);
      Description

      As mentioned above, if vkCreateSwapchainKHR succeeds, it will return a handle to a swapchain containing an array of at least pCreateInfo→minImageCount presentable images.

      While acquired by the application, presentable images can be used in any way that equivalent non-presentable images can be used. A presentable image is equivalent to a non-presentable image created with the following VkImageCreateInfo parameters:

      VkImageCreateInfo FieldValue
      flagsIMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT is set if SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR is set IMAGE_CREATE_PROTECTED_BIT is set if SWAPCHAIN_CREATE_PROTECTED_BIT_KHR is set IMAGE_CREATE_MUTABLE_FORMAT_BIT and IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR are both set if SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR is set all other bits are unset
      imageTypeIMAGE_TYPE_2D
      formatpCreateInfo→imageFormat
      extent{pCreateInfo→imageExtent.width, pCreateInfo→imageExtent.height, 1}
      mipLevels1
      arrayLayerspCreateInfo→imageArrayLayers
      samplesSAMPLE_COUNT_1_BIT
      tilingIMAGE_TILING_OPTIMAL
      usagepCreateInfo→imageUsage
      sharingModepCreateInfo→imageSharingMode
      queueFamilyIndexCountpCreateInfo→queueFamilyIndexCount
      pQueueFamilyIndicespCreateInfo→pQueueFamilyIndices
      initialLayoutIMAGE_LAYOUT_UNDEFINED

      The pCreateInfo→surface must not be destroyed until after the swapchain is destroyed.

      If oldSwapchain is NULL_HANDLE, and the native window referred to by pCreateInfo→surface is already associated with a Vulkan swapchain, ERROR_NATIVE_WINDOW_IN_USE_KHR must be returned.

      If the native window referred to by pCreateInfo→surface is already associated with a non-Vulkan graphics API surface, ERROR_NATIVE_WINDOW_IN_USE_KHR must be returned.

      The native window referred to by pCreateInfo→surface must not become associated with a non-Vulkan graphics API surface before all associated Vulkan swapchains have been destroyed.

      vkCreateSwapchainKHR will return ERROR_DEVICE_LOST if the logical device was lost. The VkSwapchainKHR is a child of the device, and must be destroyed before the device. However, VkSurfaceKHR is not a child of any VkDevice and is not affected by the lost device. After successfully recreating a VkDevice, the same VkSurfaceKHR can be used to create a new VkSwapchainKHR, provided the previous one was destroyed.

      If the oldSwapchain parameter of pCreateInfo is a valid swapchain, which has exclusive full-screen access, that access is released from pCreateInfo→oldSwapchain. If the command succeeds in this case, the newly created swapchain will automatically acquire exclusive full-screen access from pCreateInfo→oldSwapchain.

      Note

      This implicit transfer is intended to avoid exiting and entering full-screen exclusive mode, which may otherwise cause unwanted visual updates to the display.

      In some cases, swapchain creation may fail if exclusive full-screen mode is requested for application control, but for some implementation-specific reason exclusive full-screen access is unavailable for the particular combination of parameters provided. If this occurs, ERROR_INITIALIZATION_FAILED will be returned.

      Note

      In particular, it will fail if the imageExtent member of pCreateInfo does not match the extents of the monitor. Other reasons for failure may include the application not being set as high-dpi aware, or if the physical device and monitor are not compatible in this mode.

      If the pNext chain of VkSwapchainCreateInfoKHR includes a VkSwapchainPresentBarrierCreateInfoNV structure, then that structure includes additional swapchain creation parameters specific to the present barrier. Swapchain creation may fail if the state of the current system restricts the usage of the present barrier feature VkSurfaceCapabilitiesPresentBarrierNV, or a swapchain itself does not satisfy all the required conditions. In this scenario ERROR_INITIALIZATION_FAILED is returned.

      When the VkSurfaceKHR in VkSwapchainCreateInfoKHR is a display surface, then the VkDisplayModeKHR in display surface’s VkDisplaySurfaceCreateInfoKHR is associated with a particular VkDisplayKHR. Swapchain creation may fail if that VkDisplayKHR is not acquired by the application. In this scenario ERROR_INITIALIZATION_FAILED is returned.

      Valid Usage (Implicit)
      • device must be a valid VkDevice handle
      • pCreateInfo must be a valid pointer to a valid VkSwapchainCreateInfoKHR structure
      • If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
      • pSwapchain must be a valid pointer to a VkSwapchainKHR handle
      Host Synchronization
      • Host access to pCreateInfo→surface must be externally synchronized
      • Host access to pCreateInfo→oldSwapchain must be externally synchronized
      Return Codes
      On success, this command returns
      On failure, this command returns
      See Also

      VkAllocationCallbacks, VkSwapchainCreateInfoKHR

      Parameters:
      device - the device to create the swapchain for.
      pCreateInfo - a pointer to a VkSwapchainCreateInfoKHR structure specifying the parameters of the created swapchain.
      pAllocator - the allocator used for host memory allocated for the swapchain object when there is no more specific allocator available (see Memory Allocation).
      pSwapchain - a pointer to a VkSwapchainKHR handle in which the created swapchain object will be returned.

    • nvkDestroySwapchainKHR

      public static void nvkDestroySwapchainKHR(org.lwjgl.vulkan.VkDevice device, long swapchain, long pAllocator)
      Unsafe version of: DestroySwapchainKHR

    • vkDestroySwapchainKHR

      public static void vkDestroySwapchainKHR(org.lwjgl.vulkan.VkDevice device, long swapchain, @Nullable VkAllocationCallbacks pAllocator)
      Destroy a swapchain object.
      C Specification

      To destroy a swapchain object call:

      
 void vkDestroySwapchainKHR(
     VkDevice                                    device,
     VkSwapchainKHR                              swapchain,
     const VkAllocationCallbacks*                pAllocator);
      Description

      The application must not destroy a swapchain until after completion of all outstanding operations on images that were acquired from the swapchain. swapchain and all associated VkImage handles are destroyed, and must not be acquired or used any more by the application. The memory of each VkImage will only be freed after that image is no longer used by the presentation engine. For example, if one image of the swapchain is being displayed in a window, the memory for that image may not be freed until the window is destroyed, or another swapchain is created for the window. Destroying the swapchain does not invalidate the parent VkSurfaceKHR, and a new swapchain can be created with it.

      When a swapchain associated with a display surface is destroyed, if the image most recently presented to the display surface is from the swapchain being destroyed, then either any display resources modified by presenting images from any swapchain associated with the display surface must be reverted by the implementation to their state prior to the first present performed on one of these swapchains, or such resources must be left in their current state.

      If swapchain has exclusive full-screen access, it is released before the swapchain is destroyed.

      Valid Usage
      • All uses of presentable images acquired from swapchain must have completed execution
      • If VkAllocationCallbacks were provided when swapchain was created, a compatible set of callbacks must be provided here
      • If no VkAllocationCallbacks were provided when swapchain was created, pAllocator must be NULL
      Valid Usage (Implicit)
      • device must be a valid VkDevice handle
      • If swapchain is not NULL_HANDLE, swapchain must be a valid VkSwapchainKHR handle
      • If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
      • If swapchain is a valid handle, it must have been created, allocated, or retrieved from device
      Host Synchronization
      • Host access to swapchain must be externally synchronized
      See Also

      VkAllocationCallbacks

      Parameters:
      device - the VkDevice associated with swapchain.
      swapchain - the swapchain to destroy.
      pAllocator - the allocator used for host memory allocated for the swapchain object when there is no more specific allocator available (see Memory Allocation).

    • nvkGetSwapchainImagesKHR

      public static int nvkGetSwapchainImagesKHR(org.lwjgl.vulkan.VkDevice device, long swapchain, long pSwapchainImageCount, long pSwapchainImages)
      Unsafe version of: GetSwapchainImagesKHR
      Parameters:
      pSwapchainImageCount - a pointer to an integer related to the number of presentable images available or queried, as described below.

    • vkGetSwapchainImagesKHR

      public static int vkGetSwapchainImagesKHR(org.lwjgl.vulkan.VkDevice device, long swapchain, IntBuffer pSwapchainImageCount, @Nullable LongBuffer pSwapchainImages)
      Obtain the array of presentable images associated with a swapchain.
      C Specification

      To obtain the array of presentable images associated with a swapchain, call:

      
 VkResult vkGetSwapchainImagesKHR(
     VkDevice                                    device,
     VkSwapchainKHR                              swapchain,
     uint32_t*                                   pSwapchainImageCount,
     VkImage*                                    pSwapchainImages);
      Description

      If pSwapchainImages is NULL, then the number of presentable images for swapchain is returned in pSwapchainImageCount. Otherwise, pSwapchainImageCount must point to a variable set by the application to the number of elements in the pSwapchainImages array, and on return the variable is overwritten with the number of structures actually written to pSwapchainImages. If the value of pSwapchainImageCount is less than the number of presentable images for swapchain, at most pSwapchainImageCount structures will be written, and INCOMPLETE will be returned instead of SUCCESS, to indicate that not all the available presentable images were returned.

      Valid Usage (Implicit)
      • device must be a valid VkDevice handle
      • swapchain must be a valid VkSwapchainKHR handle
      • pSwapchainImageCount must be a valid pointer to a uint32_t value
      • If the value referenced by pSwapchainImageCount is not 0, and pSwapchainImages is not NULL, pSwapchainImages must be a valid pointer to an array of pSwapchainImageCount VkImage handles
      • swapchain must have been created, allocated, or retrieved from device
      Return Codes
      On success, this command returns
      On failure, this command returns
      Parameters:
      device - the device associated with swapchain.
      swapchain - the swapchain to query.
      pSwapchainImageCount - a pointer to an integer related to the number of presentable images available or queried, as described below.
      pSwapchainImages - either NULL or a pointer to an array of VkImage handles.

    • nvkAcquireNextImageKHR

      public static int nvkAcquireNextImageKHR(org.lwjgl.vulkan.VkDevice device, long swapchain, long timeout, long semaphore, long fence, long pImageIndex)
      Unsafe version of: AcquireNextImageKHR

    • vkAcquireNextImageKHR

      public static int vkAcquireNextImageKHR(org.lwjgl.vulkan.VkDevice device, long swapchain, long timeout, long semaphore, long fence, IntBuffer pImageIndex)
      Retrieve the index of the next available presentable image.
      C Specification

      To acquire an available presentable image to use, and retrieve the index of that image, call:

      
 VkResult vkAcquireNextImageKHR(
     VkDevice                                    device,
     VkSwapchainKHR                              swapchain,
     uint64_t                                    timeout,
     VkSemaphore                                 semaphore,
     VkFence                                     fence,
     uint32_t*                                   pImageIndex);
      Description

      If the swapchain has been created with the SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT flag, the image whose index is returned in pImageIndex will be fully backed by memory before this call returns to the application, as if it is bound completely and contiguously to a single VkDeviceMemory object.

      Valid Usage
      • swapchain must not be in the retired state
      • If semaphore is not NULL_HANDLE, it must be unsignaled
      • If semaphore is not NULL_HANDLE, it must not have any uncompleted signal or wait operations pending
      • If fence is not NULL_HANDLE, fence must be unsignaled
      • If fence is not NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue
      • semaphore and fence must not both be equal to NULL_HANDLE
      • If forward progress cannot be guaranteed for the surface used to create the swapchain member of pAcquireInfo, timeout must not be UINT64_MAX
      • semaphore must have a VkSemaphoreType of SEMAPHORE_TYPE_BINARY
      Valid Usage (Implicit)
      • device must be a valid VkDevice handle
      • swapchain must be a valid VkSwapchainKHR handle
      • If semaphore is not NULL_HANDLE, semaphore must be a valid VkSemaphore handle
      • If fence is not NULL_HANDLE, fence must be a valid VkFence handle
      • pImageIndex must be a valid pointer to a uint32_t value
      • swapchain must have been created, allocated, or retrieved from device
      • If semaphore is a valid handle, it must have been created, allocated, or retrieved from device
      • If fence is a valid handle, it must have been created, allocated, or retrieved from device
      Host Synchronization
      • Host access to swapchain must be externally synchronized
      • Host access to semaphore must be externally synchronized
      • Host access to fence must be externally synchronized
      Return Codes
      On success, this command returns
      On failure, this command returns
      Parameters:
      device - the device associated with swapchain.
      swapchain - the non-retired swapchain from which an image is being acquired.
      timeout - specifies how long the function waits, in nanoseconds, if no image is available.
      semaphore - NULL_HANDLE or a semaphore to signal.
      fence - NULL_HANDLE or a fence to signal.
      pImageIndex - a pointer to a uint32_t in which the index of the next image to use (i.e. an index into the array of images returned by vkGetSwapchainImagesKHR) is returned.

    • nvkQueuePresentKHR

      public static int nvkQueuePresentKHR(org.lwjgl.vulkan.VkQueue queue, long pPresentInfo)
      Unsafe version of: QueuePresentKHR

    • vkQueuePresentKHR

      public static int vkQueuePresentKHR(org.lwjgl.vulkan.VkQueue queue, VkPresentInfoKHR pPresentInfo)
      Queue an image for presentation.
      C Specification

      After queueing all rendering commands and transitioning the image to the correct layout, to queue an image for presentation, call:

      
 VkResult vkQueuePresentKHR(
     VkQueue                                     queue,
     const VkPresentInfoKHR*                     pPresentInfo);
      Description
      Note

      There is no requirement for an application to present images in the same order that they were acquired - applications can arbitrarily present any image that is currently acquired.

      Note

      The origin of the native orientation of the surface coordinate system is not specified in the Vulkan specification; it depends on the platform. For most platforms the origin is by default upper-left, meaning the pixel of the presented VkImage at coordinates (0,0) would appear at the upper left pixel of the platform surface (assuming SURFACE_TRANSFORM_IDENTITY_BIT_KHR, and the display standing the right way up).

      The result codes ERROR_OUT_OF_DATE_KHR and SUBOPTIMAL_KHR have the same meaning when returned by vkQueuePresentKHR as they do when returned by vkAcquireNextImageKHR. If any swapchain member of pPresentInfo was created with FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT will be returned if that swapchain does not have exclusive full-screen access, possibly for implementation-specific reasons outside of the application’s control. If multiple swapchains are presented, the result code is determined by applying the following rules in order:

      Any writes to memory backing the images referenced by the pImageIndices and pSwapchains members of pPresentInfo, that are available before QueuePresentKHR is executed, are automatically made visible to the read access performed by the presentation engine. This automatic visibility operation for an image happens-after the semaphore signal operation, and happens-before the presentation engine accesses the image.

      Presentation is a read-only operation that will not affect the content of the presentable images. Upon reacquiring the image and transitioning it away from the IMAGE_LAYOUT_PRESENT_SRC_KHR layout, the contents will be the same as they were prior to transitioning the image to the present source layout and presenting it. However, if a mechanism other than Vulkan is used to modify the platform window associated with the swapchain, the content of all presentable images in the swapchain becomes undefined.

      Calls to vkQueuePresentKHR may block, but must return in finite time. The processing of the presentation happens in issue order with other queue operations, but semaphores must be used to ensure that prior rendering and other commands in the specified queue complete before the presentation begins. The presentation command itself does not delay processing of subsequent commands on the queue. However, presentation requests sent to a particular queue are always performed in order. Exact presentation timing is controlled by the semantics of the presentation engine and native platform in use.

      If an image is presented to a swapchain created from a display surface, the mode of the associated display will be updated, if necessary, to match the mode specified when creating the display surface. The mode switch and presentation of the specified image will be performed as one atomic operation.

      Queueing an image for presentation defines a set of queue operations, including waiting on the semaphores and submitting a presentation request to the presentation engine. However, the scope of this set of queue operations does not include the actual processing of the image by the presentation engine.

      If vkQueuePresentKHR fails to enqueue the corresponding set of queue operations, it may return ERROR_OUT_OF_HOST_MEMORY or ERROR_OUT_OF_DEVICE_MEMORY. If it does, the implementation must ensure that the state and contents of any resources or synchronization primitives referenced is unaffected by the call or its failure.

      If vkQueuePresentKHR fails in such a way that the implementation is unable to make that guarantee, the implementation must return ERROR_DEVICE_LOST.

      However, if the presentation request is rejected by the presentation engine with an error ERROR_OUT_OF_DATE_KHR, ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT, or ERROR_SURFACE_LOST_KHR, the set of queue operations are still considered to be enqueued and thus any semaphore wait operation specified in VkPresentInfoKHR will execute when the corresponding queue operation is complete.

      vkQueuePresentKHR releases the acquisition of the images referenced by imageIndices. The queue family corresponding to the queue vkQueuePresentKHR is executed on must have ownership of the presented images as defined in Resource Sharing. vkQueuePresentKHR does not alter the queue family ownership, but the presented images must not be used again before they have been reacquired using vkAcquireNextImageKHR.

      Note

      The application can continue to present any acquired images from a retired swapchain as long as the swapchain has not entered a state that causes QueuePresentKHR to return ERROR_OUT_OF_DATE_KHR.

      Valid Usage
      • Each element of pSwapchains member of pPresentInfo must be a swapchain that is created for a surface for which presentation is supported from queue as determined using a call to vkGetPhysicalDeviceSurfaceSupportKHR
      • If more than one member of pSwapchains was created from a display surface, all display surfaces referenced that refer to the same display must use the same display mode
      • If more than one member of pSwapchains was created from a display surface, all display surfaces referenced that refer to the same display must use the same stereoType
      • When a semaphore wait operation referring to a binary semaphore defined by the elements of the pWaitSemaphores member of pPresentInfo executes on queue, there must be no other queues waiting on the same semaphore
      • All elements of the pWaitSemaphores member of pPresentInfo must be created with a VkSemaphoreType of SEMAPHORE_TYPE_BINARY
      • All elements of the pWaitSemaphores member of pPresentInfo must reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends must have also been submitted for execution
      Valid Usage (Implicit)
      • queue must be a valid VkQueue handle
      • pPresentInfo must be a valid pointer to a valid VkPresentInfoKHR structure
      Host Synchronization
      • Host access to queue must be externally synchronized
      • Host access to pPresentInfo→pWaitSemaphores[] must be externally synchronized
      • Host access to pPresentInfo→pSwapchains[] must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      ---Any-
      Return Codes
      On success, this command returns
      On failure, this command returns
      See Also

      VkPresentInfoKHR

      Parameters:
      queue - a queue that is capable of presentation to the target surface’s platform on the same device as the image’s swapchain.
      pPresentInfo - a pointer to a VkPresentInfoKHR structure specifying parameters of the presentation.

    • nvkGetDeviceGroupPresentCapabilitiesKHR

      public static int nvkGetDeviceGroupPresentCapabilitiesKHR(org.lwjgl.vulkan.VkDevice device, long pDeviceGroupPresentCapabilities)
      Unsafe version of: GetDeviceGroupPresentCapabilitiesKHR

    • vkGetDeviceGroupPresentCapabilitiesKHR

      public static int vkGetDeviceGroupPresentCapabilitiesKHR(org.lwjgl.vulkan.VkDevice device, VkDeviceGroupPresentCapabilitiesKHR pDeviceGroupPresentCapabilities)
      Query present capabilities from other physical devices.
      C Specification

      A logical device that represents multiple physical devices may support presenting from images on more than one physical device, or combining images from multiple physical devices.

      To query these capabilities, call:

      
 VkResult vkGetDeviceGroupPresentCapabilitiesKHR(
     VkDevice                                    device,
     VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);
      Valid Usage (Implicit)
      Return Codes
      On success, this command returns
      On failure, this command returns
      See Also

      VkDeviceGroupPresentCapabilitiesKHR

      Parameters:
      device - the logical device.
      pDeviceGroupPresentCapabilities - a pointer to a VkDeviceGroupPresentCapabilitiesKHR structure in which the device’s capabilities are returned.

    • nvkGetDeviceGroupSurfacePresentModesKHR

      public static int nvkGetDeviceGroupSurfacePresentModesKHR(org.lwjgl.vulkan.VkDevice device, long surface, long pModes)
      Unsafe version of: GetDeviceGroupSurfacePresentModesKHR

    • vkGetDeviceGroupSurfacePresentModesKHR

      public static int vkGetDeviceGroupSurfacePresentModesKHR(org.lwjgl.vulkan.VkDevice device, long surface, IntBuffer pModes)
      Query present capabilities for a surface.
      C Specification

      Some surfaces may not be capable of using all the device group present modes.

      To query the supported device group present modes for a particular surface, call:

      
 VkResult vkGetDeviceGroupSurfacePresentModesKHR(
     VkDevice                                    device,
     VkSurfaceKHR                                surface,
     VkDeviceGroupPresentModeFlagsKHR*           pModes);
      Description

      The modes returned by this command are not invariant, and may change in response to the surface being moved, resized, or occluded. These modes must be a subset of the modes returned by GetDeviceGroupPresentCapabilitiesKHR.

      Valid Usage
      • surface must be supported by all physical devices associated with device, as reported by GetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism
      Valid Usage (Implicit)
      • device must be a valid VkDevice handle
      • surface must be a valid VkSurfaceKHR handle
      • pModes must be a valid pointer to a VkDeviceGroupPresentModeFlagsKHR value
      • Both of device, and surface must have been created, allocated, or retrieved from the same VkInstance
      Host Synchronization
      • Host access to surface must be externally synchronized
      Return Codes
      On success, this command returns
      On failure, this command returns
      Parameters:
      device - the logical device.
      surface - the surface.
      pModes - a pointer to a VkDeviceGroupPresentModeFlagsKHR in which the supported device group present modes for the surface are returned.

    • nvkGetPhysicalDevicePresentRectanglesKHR

      public static int nvkGetPhysicalDevicePresentRectanglesKHR(org.lwjgl.vulkan.VkPhysicalDevice physicalDevice, long surface, long pRectCount, long pRects)
      Unsafe version of: GetPhysicalDevicePresentRectanglesKHR
      Parameters:
      pRectCount - a pointer to an integer related to the number of rectangles available or queried, as described below.

    • vkGetPhysicalDevicePresentRectanglesKHR

      public static int vkGetPhysicalDevicePresentRectanglesKHR(org.lwjgl.vulkan.VkPhysicalDevice physicalDevice, long surface, IntBuffer pRectCount, @Nullable VkRect2D.Buffer pRects)
      Query present rectangles for a surface on a physical device.
      C Specification

      When using DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR, the application may need to know which regions of the surface are used when presenting locally on each physical device. Presentation of swapchain images to this surface need only have valid contents in the regions returned by this command.

      To query a set of rectangles used in presentation on the physical device, call:

      
 VkResult vkGetPhysicalDevicePresentRectanglesKHR(
     VkPhysicalDevice                            physicalDevice,
     VkSurfaceKHR                                surface,
     uint32_t*                                   pRectCount,
     VkRect2D*                                   pRects);
      Description

      If pRects is NULL, then the number of rectangles used when presenting the given surface is returned in pRectCount. Otherwise, pRectCount must point to a variable set by the application to the number of elements in the pRects array, and on return the variable is overwritten with the number of structures actually written to pRects. If the value of pRectCount is less than the number of rectangles, at most pRectCount structures will be written, and INCOMPLETE will be returned instead of SUCCESS, to indicate that not all the available rectangles were returned.

      The values returned by this command are not invariant, and may change in response to the surface being moved, resized, or occluded.

      The rectangles returned by this command must not overlap.

      Valid Usage
      • surface must be a valid VkSurfaceKHR handle
      • surface must be supported by physicalDevice, as reported by GetPhysicalDeviceSurfaceSupportKHR or an equivalent platform-specific mechanism
      Valid Usage (Implicit)
      • physicalDevice must be a valid VkPhysicalDevice handle
      • surface must be a valid VkSurfaceKHR handle
      • pRectCount must be a valid pointer to a uint32_t value
      • If the value referenced by pRectCount is not 0, and pRects is not NULL, pRects must be a valid pointer to an array of pRectCount VkRect2D structures
      • Both of physicalDevice, and surface must have been created, allocated, or retrieved from the same VkInstance
      Host Synchronization
      • Host access to surface must be externally synchronized
      Return Codes
      On success, this command returns
      On failure, this command returns
      See Also

      VkRect2D

      Parameters:
      physicalDevice - the physical device.
      surface - the surface.
      pRectCount - a pointer to an integer related to the number of rectangles available or queried, as described below.
      pRects - either NULL or a pointer to an array of VkRect2D structures.

    • nvkAcquireNextImage2KHR

      public static int nvkAcquireNextImage2KHR(org.lwjgl.vulkan.VkDevice device, long pAcquireInfo, long pImageIndex)
      Unsafe version of: AcquireNextImage2KHR

    • vkAcquireNextImage2KHR

      public static int vkAcquireNextImage2KHR(org.lwjgl.vulkan.VkDevice device, VkAcquireNextImageInfoKHR pAcquireInfo, IntBuffer pImageIndex)
      Retrieve the index of the next available presentable image.
      C Specification

      To acquire an available presentable image to use, and retrieve the index of that image, call:

      
 VkResult vkAcquireNextImage2KHR(
     VkDevice                                    device,
     const VkAcquireNextImageInfoKHR*            pAcquireInfo,
     uint32_t*                                   pImageIndex);
      Description

      If the swapchain has been created with the SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT flag, the image whose index is returned in pImageIndex will be fully backed by memory before this call returns to the application.

      Valid Usage
      • If forward progress cannot be guaranteed for the surface used to create swapchain, the timeout member of pAcquireInfo must not be UINT64_MAX
      Valid Usage (Implicit)
      • device must be a valid VkDevice handle
      • pAcquireInfo must be a valid pointer to a valid VkAcquireNextImageInfoKHR structure
      • pImageIndex must be a valid pointer to a uint32_t value
      Return Codes
      On success, this command returns
      On failure, this command returns
      See Also

      VkAcquireNextImageInfoKHR

      Parameters:
      device - the device associated with swapchain.
      pAcquireInfo - a pointer to a VkAcquireNextImageInfoKHR structure containing parameters of the acquire.
      pImageIndex - a pointer to a uint32_t value specifying the index of the next image to use.

    • vkCreateSwapchainKHR

      public static int vkCreateSwapchainKHR(org.lwjgl.vulkan.VkDevice device, VkSwapchainCreateInfoKHR pCreateInfo, @Nullable VkAllocationCallbacks pAllocator, long[] pSwapchain)
      Array version of: CreateSwapchainKHR

    • vkGetSwapchainImagesKHR

      public static int vkGetSwapchainImagesKHR(org.lwjgl.vulkan.VkDevice device, long swapchain, int[] pSwapchainImageCount, long @Nullable [] pSwapchainImages)
      Array version of: GetSwapchainImagesKHR

    • vkAcquireNextImageKHR

      public static int vkAcquireNextImageKHR(org.lwjgl.vulkan.VkDevice device, long swapchain, long timeout, long semaphore, long fence, int[] pImageIndex)
      Array version of: AcquireNextImageKHR

    • vkGetDeviceGroupSurfacePresentModesKHR

      public static int vkGetDeviceGroupSurfacePresentModesKHR(org.lwjgl.vulkan.VkDevice device, long surface, int[] pModes)
      Array version of: GetDeviceGroupSurfacePresentModesKHR

    • vkGetPhysicalDevicePresentRectanglesKHR

      public static int vkGetPhysicalDevicePresentRectanglesKHR(org.lwjgl.vulkan.VkPhysicalDevice physicalDevice, long surface, int[] pRectCount, @Nullable VkRect2D.Buffer pRects)
      Array version of: GetPhysicalDevicePresentRectanglesKHR

    • vkAcquireNextImage2KHR

      public static int vkAcquireNextImage2KHR(org.lwjgl.vulkan.VkDevice device, VkAcquireNextImageInfoKHR pAcquireInfo, int[] pImageIndex)
      Array version of: AcquireNextImage2KHR