• Home
• org.lwjgl
• lwjgl-vulkan
• 3.1.3
• source code
• KHXDeviceGroup.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.lwjgl.vulkan.KHXDeviceGroup Maven / Gradle / Ivy

/*
 * 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 org.lwjgl.system.*;

import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.JNI.*;
import static org.lwjgl.system.MemoryUtil.*;

/**
 * This extension provides functionality to use a logical device that consists of multiple physical devices, as created with the {@code VK_KHX_device_group_creation} extension. A device group can allocate memory across the subdevices, bind memory from one subdevice to a resource on another subdevice, record command buffers where some work executes on an arbitrary subset of the subdevices, and potentially present a swapchain image from one or more subdevices.
 * 
 * 
Examples
 * 
 * 
TODO
 * 
 * 

 * 
Name String
 * 
{@code VK_KHX_device_group}
 * 
Extension Type
 * 
Device extension
 * 
Registered Extension Number
 * 
61
 * 
Revision
 * 
2
 * 
Extension and Version Dependencies
 * 

 * 
Requires Vulkan 1.0
 * 
Requires {@code VK_KHX_device_group_creation}
 * 
 * 
Contact
 * 

 * 
Jeff Bolz @jbolz
 * 
 * 
Last Modified Date
 * 
2017-05-19
 * 
IP Status
 * 
No known IP claims.
 * 
Contributors
 * 

 * 
Jeff Bolz, NVIDIA
 * 
Tobias Hector, Imagination Technologies
 * 
 * 
 */
public class KHXDeviceGroup {

    /** The extension specification version. */
    public static final int VK_KHX_DEVICE_GROUP_SPEC_VERSION = 2;

    /** The extension name. */
    public static final String VK_KHX_DEVICE_GROUP_EXTENSION_NAME = "VK_KHX_device_group";

    /**
     * Extends {@code VkStructureType}.
     * 
     * 
Enum values:
     * 
     * 

     * 
{@link #VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX}
     * 
{@link #VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX             = 1000060000,
        VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX    = 1000060003,
        VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX = 1000060004,
        VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX               = 1000060005,
        VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX          = 1000060006,
        VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX                = 1000060010;

    /**
     * Extends {@code VkPipelineCreateFlagBits}.
     * 
     * 
Enum values:
     * 
     * 

     * 
{@link #VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX}
     * 
{@link #VK_PIPELINE_CREATE_DISPATCH_BASE_KHX PIPELINE_CREATE_DISPATCH_BASE_KHX}
     * 
     */
    public static final int
        VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x8,
        VK_PIPELINE_CREATE_DISPATCH_BASE_KHX                    = 0x10;

    /** Extends {@code VkDependencyFlagBits}. */
    public static final int VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x4;

    /**
     * Extends {@code VkStructureType}.
     * 
     * 
Enum values:
     * 
     * 

     * 
{@link #VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX}
     * 
{@link #VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX = 1000060013,
        VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX  = 1000060014;

    /** Extends {@code VkImageCreateFlagBits}. */
    public static final int VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x40;

    /** Extends {@code VkStructureType}. */
    public static final int VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = 1000060007;

    /**
     * Extends {@code VkStructureType}.
     * 
     * 
Enum values:
     * 
     * 

     * 
{@link #VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX}
     * 
{@link #VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX        = 1000060008,
        VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX   = 1000060009,
        VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX          = 1000060011,
        VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = 1000060012;

    /** Extends {@code VkSwapchainCreateFlagBitsKHR}. */
    public static final int VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x1;

    /**
     * VkPeerMemoryFeatureFlagBitsKHX - Bitmask specifying supported peer memory features
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX} indicates that the memory can be accessed as the source of a ftext:vkCmdCopyBuffer, ftext:vkCmdCopyImage, ftext:vkCmdCopyBufferToImage, or ftext:vkCmdCopyImageToBuffer command.
     * 
{@link #VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX} indicates that the memory can be accessed as the destination of a ftext:vkCmdCopyBuffer, ftext:vkCmdCopyImage, ftext:vkCmdCopyBufferToImage, or ftext:vkCmdCopyImageToBuffer command.
     * 
{@link #VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX} indicates that the memory can be read as any memory access type.
     * 
{@link #VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX} indicates that the memory can be written as any memory access type. Shader atomics are considered to be writes.
     * 
     * 
     * 
{@link #VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX} must be supported for all host local heaps and for at least one device local heap.
     * 
     * 
If a device does not support a peer memory feature, it is still valid to use a resource that includes both local and peer memory bindings with the corresponding access type as long as only the local bindings are actually accessed. For example, an application doing split-frame rendering would use framebuffer attachments that include both local and peer memory bindings, but would scissor the rendering to only update local memory.
     * 
     * 
See Also
     * 
     * 
{@code VkPeerMemoryFeatureFlagsKHX}
     */
    public static final int
        VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX    = 0x1,
        VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX    = 0x2,
        VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = 0x4,
        VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = 0x8;

    /**
     * VkMemoryAllocateFlagBitsKHX - Bitmask specifying flags for a device memory allocation
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX} specifies that memory will be allocated for the devices in {@link VkMemoryAllocateFlagsInfoKHX}{@code ::deviceMask}.
     * 
     * 
     * 
See Also
     * 
     * 
{@code VkMemoryAllocateFlagsKHX}
     */
    public static final int VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = 0x1;

    /**
     * VkDeviceGroupPresentModeFlagBitsKHX - Bitmask specifying supported device group present modes
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX} indicates that any physical device with a presentation engine can present its own swapchain images.
     * 
{@link #VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX} indicates that any physical device with a presentation engine can present swapchain images from any physical device in its {@code presentMask}.
     * 
{@link #VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX} indicates that any physical device with a presentation engine can present the sum of swapchain images from any physical devices in its {@code presentMask}.
     * 
{@link #VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX} indicates that multiple physical devices with a presentation engine can each present their own swapchain images.
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkDeviceGroupPresentInfoKHX}, {@code VkDeviceGroupPresentModeFlagsKHX}
     */
    public static final int
        VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX              = 0x1,
        VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX             = 0x2,
        VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX                = 0x4,
        VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = 0x8;

    protected KHXDeviceGroup() {
        throw new UnsupportedOperationException();
    }

    static boolean isAvailable(VKCapabilitiesInstance caps, java.util.Set ext) {
        return checkFunctions(
            ext.contains("VK_KHR_surface") ? caps.vkGetPhysicalDevicePresentRectanglesKHX : -1L
        );
    }

    static boolean isAvailable(VKCapabilitiesInstance capsInstance, VKCapabilitiesDevice caps, java.util.Set ext) {
        return isAvailable(capsInstance, ext) && checkFunctions(
            caps.vkGetDeviceGroupPeerMemoryFeaturesKHX, caps.vkCmdSetDeviceMaskKHX, caps.vkCmdDispatchBaseKHX, 
            ext.contains("VK_KHR_surface") ? caps.vkGetDeviceGroupPresentCapabilitiesKHX : -1L, 
            ext.contains("VK_KHR_surface") ? caps.vkGetDeviceGroupSurfacePresentModesKHX : -1L, 
            ext.contains("VK_KHR_swapchain") ? caps.vkAcquireNextImage2KHX : -1L
        );
    }

    // --- [ vkGetDeviceGroupPeerMemoryFeaturesKHX ] ---

    /** Unsafe version of: {@link #vkGetDeviceGroupPeerMemoryFeaturesKHX GetDeviceGroupPeerMemoryFeaturesKHX} */
    public static void nvkGetDeviceGroupPeerMemoryFeaturesKHX(VkDevice device, int heapIndex, int localDeviceIndex, int remoteDeviceIndex, long pPeerMemoryFeatures) {
        long __functionAddress = device.getCapabilities().vkGetDeviceGroupPeerMemoryFeaturesKHX;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPV(__functionAddress, device.address(), heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
    }

    /**
     * Query supported peer memory features of a device.
     * 
     * 
C Specification
     * 
     * 
Peer memory is memory that is allocated for a given physical device and then bound to a resource and accessed by a different physical device, in a logical device that represents multiple physical devices. Some ways of reading and writing peer memory may not be supported by a device.
     * 
     * 
To determine how peer memory can be accessed, call:
     * 
     * 
     * void vkGetDeviceGroupPeerMemoryFeaturesKHX(
     *     VkDevice                                    device,
     *     uint32_t                                    heapIndex,
     *     uint32_t                                    localDeviceIndex,
     *     uint32_t                                    remoteDeviceIndex,
     *     VkPeerMemoryFeatureFlagsKHX*                pPeerMemoryFeatures);
     * 
     * 
Valid Usage
     * 
     * 

     * 
{@code heapIndex} must be less than {@code memoryHeapCount}
     * 
{@code localDeviceIndex} must be a valid device index
     * 
{@code remoteDeviceIndex} must be a valid device index
     * 
{@code localDeviceIndex} must not equal remoteDeviceIndex
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pPeerMemoryFeatures} must be a pointer to a combination of {@code VkPeerMemoryFeatureFlagBitsKHX} values
     * 
{@code pPeerMemoryFeatures} must not be 0
     * 
     *
     * @param device              the logical device that owns the memory.
     * @param heapIndex           the index of the memory heap from which the memory is allocated.
     * @param localDeviceIndex    the device index of the physical device that performs the memory access.
     * @param remoteDeviceIndex   the device index of the physical device that the memory is allocated for.
     * @param pPeerMemoryFeatures a pointer to a bitmask of {@code VkPeerMemoryFeatureFlagBitsKHX} indicating which types of memory accesses are supported for the combination of heap, local, and remote devices.
     */
    public static void vkGetDeviceGroupPeerMemoryFeaturesKHX(VkDevice device, @NativeType("uint32_t") int heapIndex, @NativeType("uint32_t") int localDeviceIndex, @NativeType("uint32_t") int remoteDeviceIndex, @NativeType("VkPeerMemoryFeatureFlagsKHX *") IntBuffer pPeerMemoryFeatures) {
        if (CHECKS) {
            check(pPeerMemoryFeatures, 1);
        }
        nvkGetDeviceGroupPeerMemoryFeaturesKHX(device, heapIndex, localDeviceIndex, remoteDeviceIndex, memAddress(pPeerMemoryFeatures));
    }

    // --- [ vkCmdSetDeviceMaskKHX ] ---

    /**
     * Modify device mask of a command buffer.
     * 
     * 
C Specification
     * 
     * 
To update the current device mask of a command buffer, call:
     * 
     * 
     * void vkCmdSetDeviceMaskKHX(
     *     VkCommandBuffer                             commandBuffer,
     *     uint32_t                                    deviceMask);
     * 
     * 
Description
     * 
     * 
{@code deviceMask} is used to filter out subsequent commands from executing on all physical devices whose bit indices are not set in the mask.
     * 
     * 
Valid Usage
     * 
     * 

     * 
{@code deviceMask} must be a valid device mask value
     * 
{@code deviceMask} must not be zero
     * 
{@code deviceMask} must not include any set bits that were not in the {@link VkDeviceGroupCommandBufferBeginInfoKHX}{@code ::deviceMask} value when the command buffer began recording.
     * 
If {@link #vkCmdSetDeviceMaskKHX CmdSetDeviceMaskKHX} is called inside a render pass instance, {@code deviceMask} must not include any set bits that were not in the {@link VkDeviceGroupRenderPassBeginInfoKHX}{@code ::deviceMask} value when the render pass instance began recording.
     * 
     * 
     * 
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, compute, or transfer 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
Pipeline Type
Primary Secondary
Both
Graphics compute transfer

     *
     * @param commandBuffer command buffer whose current device mask is modified.
     * @param deviceMask    the new value of the current device mask.
     */
    public static void vkCmdSetDeviceMaskKHX(VkCommandBuffer commandBuffer, @NativeType("uint32_t") int deviceMask) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdSetDeviceMaskKHX;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPV(__functionAddress, commandBuffer.address(), deviceMask);
    }

    // --- [ vkCmdDispatchBaseKHX ] ---

    /**
     * Dispatch compute work items.
     * 
     * 
C Specification
     * 
     * 
To record a dispatch using non-zero base values for the components of {@code WorkgroupId}, call:
     * 
     * 
     * void vkCmdDispatchBaseKHX(
     *     VkCommandBuffer                             commandBuffer,
     *     uint32_t                                    baseGroupX,
     *     uint32_t                                    baseGroupY,
     *     uint32_t                                    baseGroupZ,
     *     uint32_t                                    groupCountX,
     *     uint32_t                                    groupCountY,
     *     uint32_t                                    groupCountZ);
     * 
     * 
Description
     * 
     * 
When the command is executed, a global workgroup consisting of groupCountX {times} groupCountY {times} groupCountZ local workgroups is assembled, with {@code WorkgroupId} values ranging from [baseGroup, baseGroup {plus} groupCount) in each component. {@link VK10#vkCmdDispatch CmdDispatch} is equivalent to vkCmdDispatchBaseKHX(0,0,0,groupCountX,groupCountY,groupCountZ).
     * 
     * 
Valid Usage
     * 
     * 

     * 
All valid usage rules from {@link VK10#vkCmdDispatch CmdDispatch} apply
     * 
{@code baseGroupX} must be less than {@link VkPhysicalDeviceLimits}{@code ::maxComputeWorkGroupCount}[0]
     * 
{@code baseGroupX} must be less than {@code VkPhysicaYDeviceLimits}{@code ::maxComputeWorkGroupCount}[1]
     * 
{@code baseGroupZ} must be less than {@link VkPhysicalDeviceLimits}{@code ::maxComputeWorkGroupCount}[2]
     * 
{@code groupCountX} must be less than or equal to {@link VkPhysicalDeviceLimits}{@code ::maxComputeWorkGroupCount}[0] minus {@code baseGroupX}
     * 
{@code groupCountY} must be less than or equal to {@link VkPhysicalDeviceLimits}{@code ::maxComputeWorkGroupCount}[1] minus {@code baseGroupY}
     * 
{@code groupCountZ} must be less than or equal to {@link VkPhysicalDeviceLimits}{@code ::maxComputeWorkGroupCount}[2] minus {@code baseGroupZ}
     * 
If any of {@code baseGroupX}, {@code baseGroupY}, or {@code baseGroupZ} are not zero, then the currently bound compute pipeline must have been created with the {@link #VK_PIPELINE_CREATE_DISPATCH_BASE_KHX PIPELINE_CREATE_DISPATCH_BASE_KHX} flag.
     * 
     * 
     * 
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 compute operations
     * 
This command must only be called outside of a render pass instance
     * 
     * 
     * 
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
Pipeline Type
Primary Secondary
Outside
Compute

     *
     * @param commandBuffer the command buffer into which the command will be recorded.
     * @param baseGroupX    the start value for the X component of {@code WorkgroupId}.
     * @param baseGroupY    the start value for the Y component of {@code WorkgroupId}.
     * @param baseGroupZ    the start value for the Z component of {@code WorkgroupId}.
     * @param groupCountX   the number of local workgroups to dispatch in the X dimension.
     * @param groupCountY   the number of local workgroups to dispatch in the Y dimension.
     * @param groupCountZ   the number of local workgroups to dispatch in the Z dimension.
     */
    public static void vkCmdDispatchBaseKHX(VkCommandBuffer commandBuffer, @NativeType("uint32_t") int baseGroupX, @NativeType("uint32_t") int baseGroupY, @NativeType("uint32_t") int baseGroupZ, @NativeType("uint32_t") int groupCountX, @NativeType("uint32_t") int groupCountY, @NativeType("uint32_t") int groupCountZ) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdDispatchBaseKHX;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPV(__functionAddress, commandBuffer.address(), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
    }

    // --- [ vkGetDeviceGroupPresentCapabilitiesKHX ] ---

    /** Unsafe version of: {@link #vkGetDeviceGroupPresentCapabilitiesKHX GetDeviceGroupPresentCapabilitiesKHX} */
    public static int nvkGetDeviceGroupPresentCapabilitiesKHX(VkDevice device, long pDeviceGroupPresentCapabilities) {
        long __functionAddress = device.getCapabilities().vkGetDeviceGroupPresentCapabilitiesKHX;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(__functionAddress, device.address(), 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 vkGetDeviceGroupPresentCapabilitiesKHX(
     *     VkDevice                                    device,
     *     VkDeviceGroupPresentCapabilitiesKHX*        pDeviceGroupPresentCapabilities);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pDeviceGroupPresentCapabilities} must be a pointer to a {@link VkDeviceGroupPresentCapabilitiesKHX} structure
     * 
     * 
     * 
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 VkDeviceGroupPresentCapabilitiesKHX}
     *
     * @param device                          the logical device.
     * @param pDeviceGroupPresentCapabilities a pointer to a structure of type {@link VkDeviceGroupPresentCapabilitiesKHX} that is filled with the logical device’s capabilities.
     */
    @NativeType("VkResult")
    public static int vkGetDeviceGroupPresentCapabilitiesKHX(VkDevice device, @NativeType("VkDeviceGroupPresentCapabilitiesKHX *") VkDeviceGroupPresentCapabilitiesKHX pDeviceGroupPresentCapabilities) {
        return nvkGetDeviceGroupPresentCapabilitiesKHX(device, pDeviceGroupPresentCapabilities.address());
    }

    // --- [ vkGetDeviceGroupSurfacePresentModesKHX ] ---

    /** Unsafe version of: {@link #vkGetDeviceGroupSurfacePresentModesKHX GetDeviceGroupSurfacePresentModesKHX} */
    public static int nvkGetDeviceGroupSurfacePresentModesKHX(VkDevice device, long surface, long pModes) {
        long __functionAddress = device.getCapabilities().vkGetDeviceGroupSurfacePresentModesKHX;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJPI(__functionAddress, device.address(), surface, 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 vkGetDeviceGroupSurfacePresentModesKHX(
     *     VkDevice                                    device,
     *     VkSurfaceKHR                                surface,
     *     VkDeviceGroupPresentModeFlagsKHX*           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 {@link #vkGetDeviceGroupPresentCapabilitiesKHX GetDeviceGroupPresentCapabilitiesKHX}.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code surface} must be a valid {@code VkSurfaceKHR} handle
     * 
{@code pModes} must be a pointer to a combination of {@code VkDeviceGroupPresentModeFlagBitsKHX} values
     * 
{@code pModes} must not be 0
     * 
Both of {@code device}, and {@code surface} must have been created, allocated, or retrieved from the same {@code VkInstance}
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code surface} 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 KHRSurface#VK_ERROR_SURFACE_LOST_KHR ERROR_SURFACE_LOST_KHR}
     * 
     * 
     *
     * @param device  the logical device.
     * @param surface the surface.
     * @param pModes  a pointer to a value of type {@code VkDeviceGroupPresentModeFlagsKHX} that is filled with the supported device group present modes for the surface.
     */
    @NativeType("VkResult")
    public static int vkGetDeviceGroupSurfacePresentModesKHX(VkDevice device, @NativeType("VkSurfaceKHR") long surface, @NativeType("VkDeviceGroupPresentModeFlagsKHX *") IntBuffer pModes) {
        if (CHECKS) {
            check(pModes, 1);
        }
        return nvkGetDeviceGroupSurfacePresentModesKHX(device, surface, memAddress(pModes));
    }

    // --- [ vkGetPhysicalDevicePresentRectanglesKHX ] ---

    /**
     * Unsafe version of: {@link #vkGetPhysicalDevicePresentRectanglesKHX GetPhysicalDevicePresentRectanglesKHX}
     *
     * @param pRectCount a pointer to an integer related to the number of rectangles available or queried, as described below.
     */
    public static int nvkGetPhysicalDevicePresentRectanglesKHX(VkPhysicalDevice physicalDevice, long surface, long pRectCount, long pRects) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDevicePresentRectanglesKHX;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJPPI(__functionAddress, physicalDevice.address(), surface, pRectCount, pRects);
    }

    /**
     * Query present rectangles for a surface on a physical device.
     * 
     * 
C Specification
     * 
     * 
When using {@link #VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX}, 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 vkGetPhysicalDevicePresentRectanglesKHX(
     *     VkPhysicalDevice                            physicalDevice,
     *     VkSurfaceKHR                                surface,
     *     uint32_t*                                   pRectCount,
     *     VkRect2D*                                   pRects);
     * 
     * 
Description
     * 
     * 
If {@code pRects} is {@code NULL}, then the number of rectangles used when presenting the given {@code surface} is returned in {@code pRectCount}. Otherwise, {@code pRectCount} must point to a variable set by the user to the number of elements in the {@code pRects} array, and on return the variable is overwritten with the number of structures actually written to {@code pRects}. If the value of {@code pRectCount} is less than the number of rectangles, at most {@code pRectCount} structures will be written. If {@code pRectCount} is smaller than the number of rectangles used for the given {@code surface}, {@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.
     * 
     * 
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)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code surface} must be a valid {@code VkSurfaceKHR} handle
     * 
{@code pRectCount} must be a pointer to a {@code uint32_t} value
     * 
If the value referenced by {@code pRectCount} is not 0, and {@code pRects} is not {@code NULL}, {@code pRects} must be a pointer to an array of {@code pRectCount} {@link VkRect2D} structures
     * 
Both of {@code physicalDevice}, and {@code surface} must have been created, allocated, or retrieved from the same {@code VkInstance}
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code surface} must be externally synchronized
     * 
     * 
     * 
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 VkRect2D}
     *
     * @param physicalDevice the physical device.
     * @param surface        the surface.
     * @param pRectCount     a pointer to an integer related to the number of rectangles available or queried, as described below.
     * @param pRects         either {@code NULL} or a pointer to an array of {@link VkRect2D} structures.
     */
    @NativeType("VkResult")
    public static int vkGetPhysicalDevicePresentRectanglesKHX(VkPhysicalDevice physicalDevice, @NativeType("VkSurfaceKHR") long surface, @NativeType("uint32_t *") IntBuffer pRectCount, @NativeType("VkRect2D *") VkRect2D.Buffer pRects) {
        if (CHECKS) {
            check(pRectCount, 1);
            checkSafe(pRects, pRectCount.get(pRectCount.position()));
        }
        return nvkGetPhysicalDevicePresentRectanglesKHX(physicalDevice, surface, memAddress(pRectCount), memAddressSafe(pRects));
    }

    // --- [ vkAcquireNextImage2KHX ] ---

    /** Unsafe version of: {@link #vkAcquireNextImage2KHX AcquireNextImage2KHX} */
    public static int nvkAcquireNextImage2KHX(VkDevice device, long pAcquireInfo, long pImageIndex) {
        long __functionAddress = device.getCapabilities().vkAcquireNextImage2KHX;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPPI(__functionAddress, device.address(), pAcquireInfo, 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 vkAcquireNextImage2KHX(
     *     VkDevice                                    device,
     *     const VkAcquireNextImageInfoKHX*            pAcquireInfo,
     *     uint32_t*                                   pImageIndex);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pAcquireInfo} must be a pointer to a valid {@link VkAcquireNextImageInfoKHX} structure
     * 
{@code pImageIndex} must be a pointer to a {@code uint32_t} value
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
{@link VK10#VK_TIMEOUT TIMEOUT}
     * 
{@link VK10#VK_NOT_READY NOT_READY}
     * 
{@link KHRSwapchain#VK_SUBOPTIMAL_KHR SUBOPTIMAL_KHR}
     * 
     * 
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_DEVICE_LOST ERROR_DEVICE_LOST}
     * 
{@link KHRSwapchain#VK_ERROR_OUT_OF_DATE_KHR ERROR_OUT_OF_DATE_KHR}
     * 
{@link KHRSurface#VK_ERROR_SURFACE_LOST_KHR ERROR_SURFACE_LOST_KHR}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkAcquireNextImageInfoKHX}
     *
     * @param device       the device associated with {@code swapchain}.
     * @param pAcquireInfo a pointer to a structure of type {@link VkAcquireNextImageInfoKHX} containing parameters of the acquire.
     * @param pImageIndex  a pointer to a {@code uint32_t} that is set to the index of the next image to use.
     */
    @NativeType("VkResult")
    public static int vkAcquireNextImage2KHX(VkDevice device, @NativeType("const VkAcquireNextImageInfoKHX *") VkAcquireNextImageInfoKHX pAcquireInfo, @NativeType("uint32_t *") IntBuffer pImageIndex) {
        if (CHECKS) {
            check(pImageIndex, 1);
        }
        return nvkAcquireNextImage2KHX(device, pAcquireInfo.address(), memAddress(pImageIndex));
    }

    /** Array version of: {@link #vkGetDeviceGroupPeerMemoryFeaturesKHX GetDeviceGroupPeerMemoryFeaturesKHX} */
    public static void vkGetDeviceGroupPeerMemoryFeaturesKHX(VkDevice device, @NativeType("uint32_t") int heapIndex, @NativeType("uint32_t") int localDeviceIndex, @NativeType("uint32_t") int remoteDeviceIndex, @NativeType("VkPeerMemoryFeatureFlagsKHX *") int[] pPeerMemoryFeatures) {
        long __functionAddress = device.getCapabilities().vkGetDeviceGroupPeerMemoryFeaturesKHX;
        if (CHECKS) {
            check(__functionAddress);
            check(pPeerMemoryFeatures, 1);
        }
        callPPV(__functionAddress, device.address(), heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
    }

    /** Array version of: {@link #vkGetDeviceGroupSurfacePresentModesKHX GetDeviceGroupSurfacePresentModesKHX} */
    @NativeType("VkResult")
    public static int vkGetDeviceGroupSurfacePresentModesKHX(VkDevice device, @NativeType("VkSurfaceKHR") long surface, @NativeType("VkDeviceGroupPresentModeFlagsKHX *") int[] pModes) {
        long __functionAddress = device.getCapabilities().vkGetDeviceGroupSurfacePresentModesKHX;
        if (CHECKS) {
            check(__functionAddress);
            check(pModes, 1);
        }
        return callPJPI(__functionAddress, device.address(), surface, pModes);
    }

    /** Array version of: {@link #vkGetPhysicalDevicePresentRectanglesKHX GetPhysicalDevicePresentRectanglesKHX} */
    @NativeType("VkResult")
    public static int vkGetPhysicalDevicePresentRectanglesKHX(VkPhysicalDevice physicalDevice, @NativeType("VkSurfaceKHR") long surface, @NativeType("uint32_t *") int[] pRectCount, @NativeType("VkRect2D *") VkRect2D.Buffer pRects) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDevicePresentRectanglesKHX;
        if (CHECKS) {
            check(__functionAddress);
            check(pRectCount, 1);
            checkSafe(pRects, pRectCount[0]);
        }
        return callPJPPI(__functionAddress, physicalDevice.address(), surface, pRectCount, memAddressSafe(pRects));
    }

    /** Array version of: {@link #vkAcquireNextImage2KHX AcquireNextImage2KHX} */
    @NativeType("VkResult")
    public static int vkAcquireNextImage2KHX(VkDevice device, @NativeType("const VkAcquireNextImageInfoKHX *") VkAcquireNextImageInfoKHX pAcquireInfo, @NativeType("uint32_t *") int[] pImageIndex) {
        long __functionAddress = device.getCapabilities().vkAcquireNextImage2KHX;
        if (CHECKS) {
            check(__functionAddress);
            check(pImageIndex, 1);
        }
        return callPPPI(__functionAddress, device.address(), pAcquireInfo.address(), pImageIndex);
    }

}