Class KHRSwapchain


  • public class KHRSwapchain
    extends java.lang.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/master/cube/cube.c).

    Name String
    VK_KHR_swapchain
    Extension Type
    Device extension
    Registered Extension Number
    2
    Revision
    70
    Extension and Version Dependencies
    Contact
    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
    • Jason Ekstrand, Intel
    • Matthaeus G. Chajdas, AMD
    • Ray Smith, ARM
    • Method Detail

      • nvkCreateSwapchainKHR

        public static int nvkCreateSwapchainKHR​(VkDevice device,
                                                long pCreateInfo,
                                                long pAllocator,
                                                long pSwapchain)
        Unsafe version of: CreateSwapchainKHR
      • vkCreateSwapchainKHR

        public static int vkCreateSwapchainKHR​(VkDevice device,
                                               VkSwapchainCreateInfoKHR pCreateInfo,
                                               @Nullable
                                               VkAllocationCallbacks pAllocator,
                                               java.nio.LongBuffer pSwapchain)
        Create a swapchain.
        C Specification

        To create a swapchain, call:

        
         VkResult vkCreateSwapchainKHR(
             VkDevice                                    device,
             const VkSwapchainCreateInfoKHR*             pCreateInfo,
             const VkAllocationCallbacks*                pAllocator,
             VkSwapchainKHR*                             pSwapchain);
        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 an instance of the 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​(VkDevice device,
                                                  long swapchain,
                                                  long pAllocator)
        Unsafe version of: DestroySwapchainKHR
      • vkDestroySwapchainKHR

        public static void vkDestroySwapchainKHR​(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.

        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
        • Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance
        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​(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​(VkDevice device,
                                                  long swapchain,
                                                  java.nio.IntBuffer pSwapchainImageCount,
                                                  @Nullable
                                                  java.nio.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 user 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. If pSwapchainImageCount is smaller than the number of presentable images for swapchain, INCOMPLETE will be returned instead of SUCCESS to indicate that not all the available values 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
        • Both of device, and swapchain must have been created, allocated, or retrieved from the same VkInstance
        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​(VkDevice device,
                                                 long swapchain,
                                                 long timeout,
                                                 long semaphore,
                                                 long fence,
                                                 long pImageIndex)
        Unsafe version of: AcquireNextImageKHR
      • vkAcquireNextImageKHR

        public static int vkAcquireNextImageKHR​(VkDevice device,
                                                long swapchain,
                                                long timeout,
                                                long semaphore,
                                                long fence,
                                                java.nio.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);
        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 it must be unsignaled and 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 the number of currently acquired images is greater than the difference between the number of images in swapchain and the value of VkSurfaceCapabilitiesKHR::minImageCount as returned by a call to GetPhysicalDeviceSurfaceCapabilities2KHR with the surface used to create swapchain, timeout must not be UINT64_MAX
        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
        • 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
        • Both of device, and swapchain that are valid handles must have been created, allocated, or retrieved from the same VkInstance
        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 that is set to the index of the next image to use (i.e. an index into the array of images returned by GetSwapchainImagesKHR).
      • nvkQueuePresentKHR

        public static int nvkQueuePresentKHR​(VkQueue queue,
                                             long pPresentInfo)
        Unsafe version of: QueuePresentKHR
      • vkQueuePresentKHR

        public static int vkQueuePresentKHR​(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.

        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 GetPhysicalDeviceSurfaceSupportKHR
        • 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
        • When a semaphore unsignal operation defined by the elements of the pWaitSemaphores member of pPresentInfo executes on queue, no other queue must be waiting on the same semaphore.
        • All elements of the pWaitSemaphores member of pPresentInfo must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution.

        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.

        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 QueuePresentKHR 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 QueuePresentKHR 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 or ERROR_SURFACE_LOST_KHR, the set of queue operations are still considered to be enqueued and thus any semaphore to be waited on gets unsignaled when the corresponding queue operation is complete.

        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 ScopeSupported Queue TypesPipeline 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 an instance of the VkPresentInfoKHR structure specifying the parameters of the presentation.
      • vkGetDeviceGroupPresentCapabilitiesKHR

        public static int vkGetDeviceGroupPresentCapabilitiesKHR​(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 structure of type VkDeviceGroupPresentCapabilitiesKHR that is filled with the logical device’s capabilities.
      • vkGetDeviceGroupSurfacePresentModesKHR

        public static int vkGetDeviceGroupSurfacePresentModesKHR​(VkDevice device,
                                                                 long surface,
                                                                 java.nio.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 (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 value of type VkDeviceGroupPresentModeFlagsKHR that is filled with the supported device group present modes for the surface.
      • nvkGetPhysicalDevicePresentRectanglesKHR

        public static int nvkGetPhysicalDevicePresentRectanglesKHR​(VkPhysicalDevice physicalDevice,
                                                                   long surface,
                                                                   long pRectCount,
                                                                   long pRects)
        Parameters:
        pRectCount - a pointer to an integer related to the number of rectangles available or queried, as described below.
      • vkGetPhysicalDevicePresentRectanglesKHR

        public static int vkGetPhysicalDevicePresentRectanglesKHR​(VkPhysicalDevice physicalDevice,
                                                                  long surface,
                                                                  java.nio.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 user 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. If pRectCount is smaller than the number of rectangles used for the given surface, INCOMPLETE will be returned instead of SUCCESS to indicate that not all the available values 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 (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​(VkDevice device,
                                                  long pAcquireInfo,
                                                  long pImageIndex)
        Unsafe version of: AcquireNextImage2KHR
      • vkGetSwapchainImagesKHR

        public static int vkGetSwapchainImagesKHR​(VkDevice device,
                                                  long swapchain,
                                                  int[] pSwapchainImageCount,
                                                  @Nullable
                                                  long[] pSwapchainImages)
        Array version of: GetSwapchainImagesKHR
      • vkAcquireNextImageKHR

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