• Home
• org.lwjgl
• lwjgl-vulkan
• 3.3.0
• source code
• VK11.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.VK11 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 javax.annotation.*;

import java.nio.*;

import org.lwjgl.*;

import org.lwjgl.system.*;

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

/**
 * The core Vulkan 1.1 functionality.
 * 
 * 
Vulkan Version 1.1 promoted a number of key extensions into the core API:
 * 
 * 

 * 
{@link KHR16bitStorage KHR_16bit_storage}
 * 
{@link KHRBindMemory2 KHR_bind_memory2}
 * 
{@link KHRDedicatedAllocation KHR_dedicated_allocation}
 * 
{@link KHRDescriptorUpdateTemplate KHR_descriptor_update_template}
 * 
{@link KHRDeviceGroup KHR_device_group}
 * 
{@link KHRDeviceGroupCreation KHR_device_group_creation}
 * 
{@link KHRExternalMemory KHR_external_memory}
 * 
{@link KHRExternalMemoryCapabilities KHR_external_memory_capabilities}
 * 
{@link KHRExternalSemaphore KHR_external_semaphore}
 * 
{@link KHRExternalSemaphoreCapabilities KHR_external_semaphore_capabilities}
 * 
{@link KHRExternalFence KHR_external_fence}
 * 
{@link KHRExternalFenceCapabilities KHR_external_fence_capabilities}
 * 
{@link KHRGetMemoryRequirements2 KHR_get_memory_requirements2}
 * 
{@link KHRGetPhysicalDeviceProperties2 KHR_get_physical_device_properties2}
 * 
{@link KHRMaintenance1 KHR_maintenance1}
 * 
{@link KHRMaintenance2 KHR_maintenance2}
 * 
{@link KHRMaintenance3 KHR_maintenance3}
 * 
{@link KHRMultiview KHR_multiview}
 * 
{@link KHRRelaxedBlockLayout KHR_relaxed_block_layout}
 * 
{@link KHRSamplerYcbcrConversion KHR_sampler_ycbcr_conversion}
 * 
{@link KHRShaderDrawParameters KHR_shader_draw_parameters}
 * 
{@link KHRStorageBufferStorageClass KHR_storage_buffer_storage_class}
 * 
{@link KHRVariablePointers KHR_variable_pointers}
 * 
 * 
 * 
The only changes to the functionality added by these extensions were to {@code VK_KHR_shader_draw_parameters}, which had a
 * feature bit
 * added to determine support in the core API, and
 * {@code variablePointersStorageBuffer}
 * from {@code VK_KHR_variable_pointers} was made optional.
 * 
 * 
Additionally, Vulkan 1.1 added support for {@link VkPhysicalDeviceSubgroupProperties subgroup operations},
 * {@link VkPhysicalDeviceProtectedMemoryFeatures protected memory}, and a new command to {@link VK11#vkEnumerateInstanceVersion enumerate the
 * instance version}.
 */
public class VK11 extends VK10 {

    /** Extends {@code VkStructureType}. */
    public static final int VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000;

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

     * 
{@link #VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000,
        VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO  = 1000157001;

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

    /** Extends {@code VkStructureType}. */
    public static final int VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000;

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

     * 
{@link #VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS}
     * 
{@link #VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS  = 1000127000,
        VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001;

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

     * 
{@link #VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO             = 1000060000,
        VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO    = 1000060003,
        VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004,
        VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO               = 1000060005,
        VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO          = 1000060006;

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

     * 
{@link #VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT}
     * 
{@link #VK_PIPELINE_CREATE_DISPATCH_BASE_BIT PIPELINE_CREATE_DISPATCH_BASE_BIT}
     * 
{@link #VK_PIPELINE_CREATE_DISPATCH_BASE PIPELINE_CREATE_DISPATCH_BASE}
     * 
     */
    public static final int
        VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x8,
        VK_PIPELINE_CREATE_DISPATCH_BASE_BIT                = 0x10,
        VK_PIPELINE_CREATE_DISPATCH_BASE                    = 0x10;

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

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

     * 
{@link #VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013,
        VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO  = 1000060014;

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

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

     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000,
        VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO  = 1000070001;

    /** Extends {@code VkMemoryHeapFlagBits}. */
    public static final int VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x2;

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

     * 
{@link #VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2}
     * 
{@link #VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2}
     * 
{@link #VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2}
     * 
{@link #VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2}
     * 
{@link #VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2       = 1000146000,
        VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2        = 1000146001,
        VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002,
        VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2                   = 1000146003,
        VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2      = 1000146004;

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

     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2}
     * 
{@link #VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 STRUCTURE_TYPE_FORMAT_PROPERTIES_2}
     * 
{@link #VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2}
     * 
{@link #VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2}
     * 
{@link #VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2                 = 1000059000,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2               = 1000059001,
        VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2                        = 1000059002,
        VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2                  = 1000059003,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2        = 1000059004,
        VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2                  = 1000059005,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2        = 1000059006,
        VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2           = 1000059007,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008;

    /** Extends {@code VkResult}. */
    public static final int VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000;

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

     * 
{@link #VK_FORMAT_FEATURE_TRANSFER_SRC_BIT FORMAT_FEATURE_TRANSFER_SRC_BIT}
     * 
{@link #VK_FORMAT_FEATURE_TRANSFER_DST_BIT FORMAT_FEATURE_TRANSFER_DST_BIT}
     * 
     */
    public static final int
        VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x4000,
        VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x8000;

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

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

     * 
{@link #VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT}
     * 
{@link #VK_IMAGE_CREATE_EXTENDED_USAGE_BIT IMAGE_CREATE_EXTENDED_USAGE_BIT}
     * 
     */
    public static final int
        VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x80,
        VK_IMAGE_CREATE_EXTENDED_USAGE_BIT              = 0x100;

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

     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES}
     * 
{@link #VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES             = 1000117000,
        VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO       = 1000117001,
        VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO                          = 1000117002,
        VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003;

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

     * 
{@link #VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL}
     * 
{@link #VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL}
     * 
     */
    public static final int
        VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
        VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001;

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

     * 
{@link #VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO    = 1000053000,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES   = 1000053001,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002;

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

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

     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES  = 1000120000;

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

     * 
{@link #VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO                       = 1000145000,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES   = 1000145001,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002,
        VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2                         = 1000145003;

    /** Extends {@code VkQueueFlagBits}. */
    public static final int VK_QUEUE_PROTECTED_BIT = 0x10;

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

    /** Extends {@code VkMemoryPropertyFlagBits}. */
    public static final int VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x20;

    /** Extends {@code VkBufferCreateFlagBits}. */
    public static final int VK_BUFFER_CREATE_PROTECTED_BIT = 0x8;

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

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

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

     * 
{@link #VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES}
     * 
{@link #VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO              = 1000156000,
        VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO                     = 1000156001,
        VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO                      = 1000156002,
        VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO              = 1000156003,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,
        VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES  = 1000156005;

    /** Extends {@code VkObjectType}. */
    public static final int VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000;

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

     * 
{@link #VK_FORMAT_G8B8G8R8_422_UNORM FORMAT_G8B8G8R8_422_UNORM}
     * 
{@link #VK_FORMAT_B8G8R8G8_422_UNORM FORMAT_B8G8R8G8_422_UNORM}
     * 
{@link #VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM FORMAT_G8_B8_R8_3PLANE_420_UNORM}
     * 
{@link #VK_FORMAT_G8_B8R8_2PLANE_420_UNORM FORMAT_G8_B8R8_2PLANE_420_UNORM}
     * 
{@link #VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM FORMAT_G8_B8_R8_3PLANE_422_UNORM}
     * 
{@link #VK_FORMAT_G8_B8R8_2PLANE_422_UNORM FORMAT_G8_B8R8_2PLANE_422_UNORM}
     * 
{@link #VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM FORMAT_G8_B8_R8_3PLANE_444_UNORM}
     * 
{@link #VK_FORMAT_R10X6_UNORM_PACK16 FORMAT_R10X6_UNORM_PACK16}
     * 
{@link #VK_FORMAT_R10X6G10X6_UNORM_2PACK16 FORMAT_R10X6G10X6_UNORM_2PACK16}
     * 
{@link #VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16}
     * 
{@link #VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16}
     * 
{@link #VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16}
     * 
{@link #VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16}
     * 
{@link #VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16}
     * 
{@link #VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16}
     * 
{@link #VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16}
     * 
{@link #VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16}
     * 
{@link #VK_FORMAT_R12X4_UNORM_PACK16 FORMAT_R12X4_UNORM_PACK16}
     * 
{@link #VK_FORMAT_R12X4G12X4_UNORM_2PACK16 FORMAT_R12X4G12X4_UNORM_2PACK16}
     * 
{@link #VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16}
     * 
{@link #VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16}
     * 
{@link #VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16}
     * 
{@link #VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16}
     * 
{@link #VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16}
     * 
{@link #VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16}
     * 
{@link #VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16}
     * 
{@link #VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16}
     * 
{@link #VK_FORMAT_G16B16G16R16_422_UNORM FORMAT_G16B16G16R16_422_UNORM}
     * 
{@link #VK_FORMAT_B16G16R16G16_422_UNORM FORMAT_B16G16R16G16_422_UNORM}
     * 
{@link #VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM FORMAT_G16_B16_R16_3PLANE_420_UNORM}
     * 
{@link #VK_FORMAT_G16_B16R16_2PLANE_420_UNORM FORMAT_G16_B16R16_2PLANE_420_UNORM}
     * 
{@link #VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM FORMAT_G16_B16_R16_3PLANE_422_UNORM}
     * 
{@link #VK_FORMAT_G16_B16R16_2PLANE_422_UNORM FORMAT_G16_B16R16_2PLANE_422_UNORM}
     * 
{@link #VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM FORMAT_G16_B16_R16_3PLANE_444_UNORM}
     * 
     */
    public static final int
        VK_FORMAT_G8B8G8R8_422_UNORM                         = 1000156000,
        VK_FORMAT_B8G8R8G8_422_UNORM                         = 1000156001,
        VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM                  = 1000156002,
        VK_FORMAT_G8_B8R8_2PLANE_420_UNORM                   = 1000156003,
        VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM                  = 1000156004,
        VK_FORMAT_G8_B8R8_2PLANE_422_UNORM                   = 1000156005,
        VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM                  = 1000156006,
        VK_FORMAT_R10X6_UNORM_PACK16                         = 1000156007,
        VK_FORMAT_R10X6G10X6_UNORM_2PACK16                   = 1000156008,
        VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16         = 1000156009,
        VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16     = 1000156010,
        VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16     = 1000156011,
        VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
        VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16  = 1000156013,
        VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
        VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16  = 1000156015,
        VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
        VK_FORMAT_R12X4_UNORM_PACK16                         = 1000156017,
        VK_FORMAT_R12X4G12X4_UNORM_2PACK16                   = 1000156018,
        VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16         = 1000156019,
        VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16     = 1000156020,
        VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16     = 1000156021,
        VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
        VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16  = 1000156023,
        VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
        VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16  = 1000156025,
        VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
        VK_FORMAT_G16B16G16R16_422_UNORM                     = 1000156027,
        VK_FORMAT_B16G16R16G16_422_UNORM                     = 1000156028,
        VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM               = 1000156029,
        VK_FORMAT_G16_B16R16_2PLANE_420_UNORM                = 1000156030,
        VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM               = 1000156031,
        VK_FORMAT_G16_B16R16_2PLANE_422_UNORM                = 1000156032,
        VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM               = 1000156033;

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

     * 
{@link #VK_IMAGE_ASPECT_PLANE_0_BIT IMAGE_ASPECT_PLANE_0_BIT}
     * 
{@link #VK_IMAGE_ASPECT_PLANE_1_BIT IMAGE_ASPECT_PLANE_1_BIT}
     * 
{@link #VK_IMAGE_ASPECT_PLANE_2_BIT IMAGE_ASPECT_PLANE_2_BIT}
     * 
     */
    public static final int
        VK_IMAGE_ASPECT_PLANE_0_BIT = 0x10,
        VK_IMAGE_ASPECT_PLANE_1_BIT = 0x20,
        VK_IMAGE_ASPECT_PLANE_2_BIT = 0x40;

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

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

     * 
{@link #VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT}
     * 
{@link #VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT}
     * 
{@link #VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT}
     * 
{@link #VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT}
     * 
{@link #VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT}
     * 
{@link #VK_FORMAT_FEATURE_DISJOINT_BIT FORMAT_FEATURE_DISJOINT_BIT}
     * 
{@link #VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT}
     * 
     */
    public static final int
        VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT                                                 = 0x20000,
        VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT                            = 0x40000,
        VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT           = 0x80000,
        VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT           = 0x100000,
        VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x200000,
        VK_FORMAT_FEATURE_DISJOINT_BIT                                                                = 0x400000,
        VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT                                                  = 0x800000;

    /** Extends {@code VkStructureType}. */
    public static final int VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000;

    /** Extends {@code VkObjectType}. */
    public static final int VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000;

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

     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000,
        VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES           = 1000071001,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO       = 1000071002,
        VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES                 = 1000071003,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES              = 1000071004;

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

     * 
{@link #VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000,
        VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO  = 1000072001,
        VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO        = 1000072002;

    /** Extends {@code VkResult}. */
    public static final int VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003;

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

     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000,
        VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES           = 1000112001;

    /** Extends {@code VkStructureType}. */
    public static final int VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000;

    /** Extends {@code VkStructureType}. */
    public static final int VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000;

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

     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO}
     * 
{@link #VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000,
        VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES           = 1000076001;

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

     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES}
     * 
{@link #VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000,
        VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT            = 1000168001;

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

     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES  = 1000063000;

    /**
     * VkSubgroupFeatureFlagBits - Bitmask describing what group operations are supported with subgroup scope
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_SUBGROUP_FEATURE_BASIC_BIT SUBGROUP_FEATURE_BASIC_BIT} specifies the device will accept SPIR-V shader modules containing the {@code GroupNonUniform} capability.
     * 
{@link #VK_SUBGROUP_FEATURE_VOTE_BIT SUBGROUP_FEATURE_VOTE_BIT} specifies the device will accept SPIR-V shader modules containing the {@code GroupNonUniformVote} capability.
     * 
{@link #VK_SUBGROUP_FEATURE_ARITHMETIC_BIT SUBGROUP_FEATURE_ARITHMETIC_BIT} specifies the device will accept SPIR-V shader modules containing the {@code GroupNonUniformArithmetic} capability.
     * 
{@link #VK_SUBGROUP_FEATURE_BALLOT_BIT SUBGROUP_FEATURE_BALLOT_BIT} specifies the device will accept SPIR-V shader modules containing the {@code GroupNonUniformBallot} capability.
     * 
{@link #VK_SUBGROUP_FEATURE_SHUFFLE_BIT SUBGROUP_FEATURE_SHUFFLE_BIT} specifies the device will accept SPIR-V shader modules containing the {@code GroupNonUniformShuffle} capability.
     * 
{@link #VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT} specifies the device will accept SPIR-V shader modules containing the {@code GroupNonUniformShuffleRelative} capability.
     * 
{@link #VK_SUBGROUP_FEATURE_CLUSTERED_BIT SUBGROUP_FEATURE_CLUSTERED_BIT} specifies the device will accept SPIR-V shader modules containing the {@code GroupNonUniformClustered} capability.
     * 
{@link #VK_SUBGROUP_FEATURE_QUAD_BIT SUBGROUP_FEATURE_QUAD_BIT} specifies the device will accept SPIR-V shader modules containing the {@code GroupNonUniformQuad} capability.
     * 
{@link NVShaderSubgroupPartitioned#VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV SUBGROUP_FEATURE_PARTITIONED_BIT_NV} specifies the device will accept SPIR-V shader modules containing the {@code GroupNonUniformPartitionedNV} capability.
     * 
     */
    public static final int
        VK_SUBGROUP_FEATURE_BASIC_BIT            = 0x1,
        VK_SUBGROUP_FEATURE_VOTE_BIT             = 0x2,
        VK_SUBGROUP_FEATURE_ARITHMETIC_BIT       = 0x4,
        VK_SUBGROUP_FEATURE_BALLOT_BIT           = 0x8,
        VK_SUBGROUP_FEATURE_SHUFFLE_BIT          = 0x10,
        VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x20,
        VK_SUBGROUP_FEATURE_CLUSTERED_BIT        = 0x40,
        VK_SUBGROUP_FEATURE_QUAD_BIT             = 0x80;

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

     * 
{@link #VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT PEER_MEMORY_FEATURE_COPY_SRC_BIT} specifies that the memory can be accessed as the source of any {@code vkCmdCopy*} command.
     * 
{@link #VK_PEER_MEMORY_FEATURE_COPY_DST_BIT PEER_MEMORY_FEATURE_COPY_DST_BIT} specifies that the memory can be accessed as the destination of any {@code vkCmdCopy*} command.
     * 
{@link #VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT PEER_MEMORY_FEATURE_GENERIC_SRC_BIT} specifies that the memory can be read as any memory access type.
     * 
{@link #VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT PEER_MEMORY_FEATURE_GENERIC_DST_BIT} specifies that the memory can be written as any memory access type. Shader atomics are considered to be writes.
     * 
     * 
     * 
Note
     * 
     * 
The peer memory features of a memory heap also apply to any accesses that may be performed during image layout transitions.
     * 
     * 
     * 
{@link #VK_PEER_MEMORY_FEATURE_COPY_DST_BIT PEER_MEMORY_FEATURE_COPY_DST_BIT} must be supported for all host local heaps and for at least one device-local memory 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.
     */
    public static final int
        VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT    = 0x1,
        VK_PEER_MEMORY_FEATURE_COPY_DST_BIT    = 0x2,
        VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x4,
        VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x8;

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

     * 
{@link #VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT MEMORY_ALLOCATE_DEVICE_MASK_BIT} specifies that memory will be allocated for the devices in {@link VkMemoryAllocateFlagsInfo}{@code ::deviceMask}.
     * 
{@link VK12#VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT} specifies that the memory can be attached to a buffer object created with the {@link VK12#VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT} bit set in {@code usage}, and that the memory handle can be used to retrieve an opaque address via {@link VK12#vkGetDeviceMemoryOpaqueCaptureAddress GetDeviceMemoryOpaqueCaptureAddress}.
     * 
{@link VK12#VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT} specifies that the memory’s address can be saved and reused on a subsequent run (e.g. for trace capture and replay), see {@link VkBufferOpaqueCaptureAddressCreateInfo} for more detail.
     * 
     */
    public static final int VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x1;

    /**
     * VkPointClippingBehavior - Enum specifying the point clipping behavior
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES} specifies that the primitive is discarded if the vertex lies outside any clip plane, including the planes bounding the view volume.
     * 
{@link #VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY} specifies that the primitive is discarded only if the vertex lies outside any user clip plane.
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPhysicalDevicePointClippingProperties}, {@link VkPhysicalDeviceVulkan11Properties}
     */
    public static final int
        VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES       = 0,
        VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1;

    /**
     * VkTessellationDomainOrigin - Enum describing tessellation domain origin
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT} specifies that the origin of the domain space is in the upper left corner, as shown in figure Domain parameterization for tessellation primitive modes (upper-left origin).
     * 
{@link #VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT} specifies that the origin of the domain space is in the lower left corner, as shown in figure Domain parameterization for tessellation primitive modes (lower-left origin).
     * 
     * 
     * 
This enum affects how the {@code VertexOrderCw} and {@code VertexOrderCcw} tessellation execution modes are interpreted, since the winding is defined relative to the orientation of the domain.
     * 
     * 
See Also
     * 
     * 
{@link VkPipelineTessellationDomainOriginStateCreateInfo}
     */
    public static final int
        VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
        VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1;

    /**
     * VkSamplerYcbcrModelConversion - Color model component of a color space
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY} specifies that the input values to the conversion are unmodified.
     * 
{@link #VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY} specifies no model conversion but the inputs are range expanded as for Y′CBCR.
     * 
{@link #VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709} specifies the color model conversion from Y′CBCR to R′G′B′ defined in BT.709 and described in the “BT.709 Y’CBCR conversion” section of the Khronos Data Format Specification.
     * 
{@link #VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601} specifies the color model conversion from Y′CBCR to R′G′B′ defined in BT.601 and described in the “BT.601 Y’CBCR conversion” section of the Khronos Data Format Specification.
     * 
{@link #VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020} specifies the color model conversion from Y′CBCR to R′G′B′ defined in BT.2020 and described in the “BT.2020 Y’CBCR conversion” section of the Khronos Data Format Specification.
     * 
     * 
     * 
In the {@code VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_*} color models, for the input to the sampler Y′CBCR range expansion and model conversion:
     * 
     * 

     * 
the Y (Y′ luma) component corresponds to the G component of an RGB image.
     * 
the CB (CB or “U” blue color difference) component corresponds to the B component of an RGB image.
     * 
the CR (CR or “V” red color difference) component corresponds to the R component of an RGB image.
     * 
the alpha component, if present, is not modified by color model conversion.
     * 
     * 
     * 
These rules reflect the mapping of components after the component swizzle operation (controlled by {@link VkSamplerYcbcrConversionCreateInfo}{@code ::components}).
     * 
     * 
Note
     * 
     * 
For example, an “{@code YUVA}” 32-bit format comprising four 8-bit components can be implemented as {@link VK10#VK_FORMAT_R8G8B8A8_UNORM FORMAT_R8G8B8A8_UNORM} with a component mapping:
     * 
     * 

     * 
{@code components.a} = {@link VK10#VK_COMPONENT_SWIZZLE_IDENTITY COMPONENT_SWIZZLE_IDENTITY}
     * 
{@code components.r} = {@link VK10#VK_COMPONENT_SWIZZLE_B COMPONENT_SWIZZLE_B}
     * 
{@code components.g} = {@link VK10#VK_COMPONENT_SWIZZLE_R COMPONENT_SWIZZLE_R}
     * 
{@code components.b} = {@link VK10#VK_COMPONENT_SWIZZLE_G COMPONENT_SWIZZLE_G}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkSamplerYcbcrConversionCreateInfo}
     */
    public static final int
        VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY   = 0,
        VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
        VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709      = 2,
        VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601      = 3,
        VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020     = 4;

    /**
     * VkSamplerYcbcrRange - Range of encoded values in a color space
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_SAMPLER_YCBCR_RANGE_ITU_FULL SAMPLER_YCBCR_RANGE_ITU_FULL} specifies that the full range of the encoded values are valid and interpreted according to the ITU “full range” quantization rules.
     * 
{@link #VK_SAMPLER_YCBCR_RANGE_ITU_NARROW SAMPLER_YCBCR_RANGE_ITU_NARROW} specifies that headroom and foot room are reserved in the numerical range of encoded values, and the remaining values are expanded according to the ITU “narrow range” quantization rules.
     * 
     * 
     * 
The formulae for these conversions is described in the Sampler Y′CBCR Range Expansion section of the Image Operations chapter.
     * 
     * 
No range modification takes place if {@code ycbcrModel} is {@link #VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY}; the {@code ycbcrRange} field of {@link VkSamplerYcbcrConversionCreateInfo} is ignored in this case.
     * 
     * 
See Also
     * 
     * 
{@link VkSamplerYcbcrConversionCreateInfo}
     */
    public static final int
        VK_SAMPLER_YCBCR_RANGE_ITU_FULL   = 0,
        VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1;

    /**
     * VkChromaLocation - Position of downsampled chroma samples
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_CHROMA_LOCATION_COSITED_EVEN CHROMA_LOCATION_COSITED_EVEN} specifies that downsampled chroma samples are aligned with luma samples with even coordinates.
     * 
{@link #VK_CHROMA_LOCATION_MIDPOINT CHROMA_LOCATION_MIDPOINT} specifies that downsampled chroma samples are located half way between each even luma sample and the nearest higher odd luma sample.
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkSamplerYcbcrConversionCreateInfo}
     */
    public static final int
        VK_CHROMA_LOCATION_COSITED_EVEN = 0,
        VK_CHROMA_LOCATION_MIDPOINT     = 1;

    /**
     * VkDescriptorUpdateTemplateType - Indicates the valid usage of the descriptor update template
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET} specifies that the descriptor update template will be used for descriptor set updates only.
     * 
{@link KHRPushDescriptor#VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR} specifies that the descriptor update template will be used for push descriptor updates only.
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkDescriptorUpdateTemplateCreateInfo}
     */
    public static final int VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0;

    /**
     * VkExternalMemoryHandleTypeFlagBits - Bit specifying external memory handle types
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT} specifies a POSIX file descriptor handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the POSIX system calls {@code dup}, {@code dup2}, {@code close}, and the non-standard system call {@code dup3}. Additionally, it must be transportable over a socket using an {@code SCM_RIGHTS} control message. It owns a reference to the underlying memory resource represented by its Vulkan memory object.
     * 
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT} specifies an NT handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the functions {@code DuplicateHandle}, {@code CloseHandle}, {@code CompareObjectHandles}, {@code GetHandleInformation}, and {@code SetHandleInformation}. It owns a reference to the underlying memory resource represented by its Vulkan memory object.
     * 
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT} specifies a global share handle that has only limited valid usage outside of Vulkan and other compatible APIs. It is not compatible with any native APIs. It does not own a reference to the underlying memory resource represented by its Vulkan memory object, and will therefore become invalid when all Vulkan memory objects associated with it are destroyed.
     * 
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT} specifies an NT handle returned by {@code IDXGIResource1}{@code ::CreateSharedHandle} referring to a Direct3D 10 or 11 texture resource. It owns a reference to the memory used by the Direct3D resource.
     * 
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT} specifies a global share handle returned by {@code IDXGIResource}{@code ::GetSharedHandle} referring to a Direct3D 10 or 11 texture resource. It does not own a reference to the underlying Direct3D resource, and will therefore become invalid when all Vulkan memory objects and Direct3D resources associated with it are destroyed.
     * 
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT} specifies an NT handle returned by {@code ID3D12Device}{@code ::CreateSharedHandle} referring to a Direct3D 12 heap resource. It owns a reference to the resources used by the Direct3D heap.
     * 
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT} specifies an NT handle returned by {@code ID3D12Device}{@code ::CreateSharedHandle} referring to a Direct3D 12 committed resource. It owns a reference to the memory used by the Direct3D resource.
     * 
{@link EXTExternalMemoryHost#VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT} specifies a host pointer returned by a host memory allocation command. It does not own a reference to the underlying memory resource, and will therefore become invalid if the host memory is freed.
     * 
{@link EXTExternalMemoryHost#VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT} specifies a host pointer to host mapped foreign memory. It does not own a reference to the underlying memory resource, and will therefore become invalid if the foreign memory is unmapped or otherwise becomes no longer available.
     * 
{@link EXTExternalMemoryDmaBuf#VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT} is a file descriptor for a Linux dma_buf. It owns a reference to the underlying memory resource represented by its Vulkan memory object.
     * 
{@link NVExternalMemoryRdma#VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV} is a handle to an allocation accessible by remote devices. It owns a reference to the underlying memory resource represented by its Vulkan memory object.
     * 
     * 
     * 
Some external memory handle types can only be shared within the same underlying physical device and/or the same driver version, as defined in the following table:
     * 
     * 
External memory handle types compatibility
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
Handle type
{@link VkPhysicalDeviceIDProperties}{@code ::driverUUID}
{@link VkPhysicalDeviceIDProperties}{@code ::deviceUUID}
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT}
Must match
Must match
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT}
Must match
Must match
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT}
Must match
Must match
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT}
Must match
Must match
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT}
Must match
Must match
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT}
Must match
Must match
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT}
Must match
Must match
{@link EXTExternalMemoryHost#VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT}
No restriction
No restriction
{@link EXTExternalMemoryHost#VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT}
No restriction
No restriction
{@link EXTExternalMemoryDmaBuf#VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT}
No restriction
No restriction
{@link NVExternalMemoryRdma#VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV}
No restriction
No restriction
     * 
     * 
Note
     * 
     * 
The above table does not restrict the drivers and devices with which {@link EXTExternalMemoryHost#VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT} and {@link EXTExternalMemoryHost#VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT} may be shared, as these handle types inherently mean memory that does not come from the same device, as they import memory from the host or a foreign device, respectively.
     * 
     * 
     * 
Note
     * 
     * 
Even though the above table does not restrict the drivers and devices with which {@link EXTExternalMemoryDmaBuf#VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT} may be shared, query mechanisms exist in the Vulkan API that prevent the import of incompatible dma-bufs (such as {@link KHRExternalMemoryFd#vkGetMemoryFdPropertiesKHR GetMemoryFdPropertiesKHR}) and that prevent incompatible usage of dma-bufs (such as {@link VkPhysicalDeviceExternalBufferInfo} and {@link VkPhysicalDeviceExternalImageFormatInfo}).
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkImportMemoryFdInfoKHR}, {@link VkImportMemoryHostPointerInfoEXT}, {@link VkImportMemoryWin32HandleInfoKHR}, {@link VkMemoryGetFdInfoKHR}, {@link VkMemoryGetRemoteAddressInfoNV}, {@link VkMemoryGetWin32HandleInfoKHR}, {@link VkPhysicalDeviceExternalBufferInfo}, {@link VkPhysicalDeviceExternalImageFormatInfo}, {@link KHRExternalMemoryFd#vkGetMemoryFdPropertiesKHR GetMemoryFdPropertiesKHR}, {@link EXTExternalMemoryHost#vkGetMemoryHostPointerPropertiesEXT GetMemoryHostPointerPropertiesEXT}, {@link KHRExternalMemoryWin32#vkGetMemoryWin32HandlePropertiesKHR GetMemoryWin32HandlePropertiesKHR}
     */
    public static final int
        VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT         = 0x1,
        VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT      = 0x2,
        VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT  = 0x4,
        VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT     = 0x8,
        VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x10,
        VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT        = 0x20,
        VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT    = 0x40;

    /**
     * VkExternalMemoryFeatureFlagBits - Bitmask specifying features of an external memory handle type
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT} specifies that images or buffers created with the specified parameters and handle type must use the mechanisms defined by {@link VkMemoryDedicatedRequirements} and {@link VkMemoryDedicatedAllocateInfo} to create (or import) a dedicated allocation for the image or buffer.
     * 
{@link #VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT} specifies that handles of this type can be exported from Vulkan memory objects.
     * 
{@link #VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT} specifies that handles of this type can be imported as Vulkan memory objects.
     * 
     * 
     * 
Because their semantics in external APIs roughly align with that of an image or buffer with a dedicated allocation in Vulkan, implementations are required to report {@link #VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT} for the following external handle types:
     * 
     * 

     * 
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT}
     * 
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT}
     * 
{@link #VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT}
     * 
     * 
     * 
Implementations must not report {@link #VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT} for images or buffers with external handle type {@link EXTExternalMemoryHost#VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT}, or {@link EXTExternalMemoryHost#VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT}.
     */
    public static final int
        VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x1,
        VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT     = 0x2,
        VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT     = 0x4;

    /**
     * VkExternalFenceHandleTypeFlagBits - Bitmask of valid external fence handle types
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT} specifies a POSIX file descriptor handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the POSIX system calls {@code dup}, {@code dup2}, {@code close}, and the non-standard system call {@code dup3}. Additionally, it must be transportable over a socket using an {@code SCM_RIGHTS} control message. It owns a reference to the underlying synchronization primitive represented by its Vulkan fence object.
     * 
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT} specifies an NT handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the functions {@code DuplicateHandle}, {@code CloseHandle}, {@code CompareObjectHandles}, {@code GetHandleInformation}, and {@code SetHandleInformation}. It owns a reference to the underlying synchronization primitive represented by its Vulkan fence object.
     * 
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT} specifies a global share handle that has only limited valid usage outside of Vulkan and other compatible APIs. It is not compatible with any native APIs. It does not own a reference to the underlying synchronization primitive represented by its Vulkan fence object, and will therefore become invalid when all Vulkan fence objects associated with it are destroyed.
     * 
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT} specifies a POSIX file descriptor handle to a Linux Sync File or Android Fence. It can be used with any native API accepting a valid sync file or fence as input. It owns a reference to the underlying synchronization primitive associated with the file descriptor. Implementations which support importing this handle type must accept any type of sync or fence FD supported by the native system they are running on.
     * 
     * 
     * 
Some external fence handle types can only be shared within the same underlying physical device and/or the same driver version, as defined in the following table:
     * 
     * 
External fence handle types compatibility
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
Handle type
{@link VkPhysicalDeviceIDProperties}{@code ::driverUUID}
{@link VkPhysicalDeviceIDProperties}{@code ::deviceUUID}
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT}
Must match
Must match
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT}
Must match
Must match
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT}
Must match
Must match
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT}
No restriction
No restriction
     * 
     * 
See Also
     * 
     * 
{@link VkFenceGetFdInfoKHR}, {@link VkFenceGetWin32HandleInfoKHR}, {@link VkImportFenceFdInfoKHR}, {@link VkImportFenceWin32HandleInfoKHR}, {@link VkPhysicalDeviceExternalFenceInfo}
     */
    public static final int
        VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT        = 0x1,
        VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT     = 0x2,
        VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x4,
        VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT          = 0x8;

    /**
     * VkExternalFenceFeatureFlagBits - Bitfield describing features of an external fence handle type
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT} specifies handles of this type can be exported from Vulkan fence objects.
     * 
{@link #VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT} specifies handles of this type can be imported to Vulkan fence objects.
     * 
     */
    public static final int
        VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x1,
        VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x2;

    /**
     * VkFenceImportFlagBits - Bitmask specifying additional parameters of fence payload import
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_FENCE_IMPORT_TEMPORARY_BIT FENCE_IMPORT_TEMPORARY_BIT} specifies that the fence payload will be imported only temporarily, as described in Importing Fence Payloads, regardless of the permanence of {@code handleType}.
     * 
     */
    public static final int VK_FENCE_IMPORT_TEMPORARY_BIT = 0x1;

    /**
     * VkSemaphoreImportFlagBits - Bitmask specifying additional parameters of semaphore payload import
     * 
     * 
Description
     * 
     * 
These bits have the following meanings:
     * 
     * 

     * 
{@link #VK_SEMAPHORE_IMPORT_TEMPORARY_BIT SEMAPHORE_IMPORT_TEMPORARY_BIT} specifies that the semaphore payload will be imported only temporarily, as described in Importing Semaphore Payloads, regardless of the permanence of {@code handleType}.
     * 
     */
    public static final int VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x1;

    /**
     * VkExternalSemaphoreHandleTypeFlagBits - Bitmask of valid external semaphore handle types
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT} specifies a POSIX file descriptor handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the POSIX system calls {@code dup}, {@code dup2}, {@code close}, and the non-standard system call {@code dup3}. Additionally, it must be transportable over a socket using an {@code SCM_RIGHTS} control message. It owns a reference to the underlying synchronization primitive represented by its Vulkan semaphore object.
     * 
{@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT} specifies an NT handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the functions {@code DuplicateHandle}, {@code CloseHandle}, {@code CompareObjectHandles}, {@code GetHandleInformation}, and {@code SetHandleInformation}. It owns a reference to the underlying synchronization primitive represented by its Vulkan semaphore object.
     * 
{@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT} specifies a global share handle that has only limited valid usage outside of Vulkan and other compatible APIs. It is not compatible with any native APIs. It does not own a reference to the underlying synchronization primitive represented by its Vulkan semaphore object, and will therefore become invalid when all Vulkan semaphore objects associated with it are destroyed.
     * 
{@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT} specifies an NT handle returned by {@code ID3D12Device}{@code ::CreateSharedHandle} referring to a Direct3D 12 fence, or {@code ID3D11Device5}{@code ::CreateFence} referring to a Direct3D 11 fence. It owns a reference to the underlying synchronization primitive associated with the Direct3D fence.
     * 
{@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT} is an alias of {@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT} with the same meaning. It is provided for convenience and code clarity when interacting with D3D11 fences.
     * 
{@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT} specifies a POSIX file descriptor handle to a Linux Sync File or Android Fence object. It can be used with any native API accepting a valid sync file or fence as input. It owns a reference to the underlying synchronization primitive associated with the file descriptor. Implementations which support importing this handle type must accept any type of sync or fence FD supported by the native system they are running on.
     * 
     * 
     * 
Note
     * 
     * 
Handles of type {@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT} generated by the implementation may represent either Linux Sync Files or Android Fences at the implementation’s discretion. Applications should only use operations defined for both types of file descriptors, unless they know via means external to Vulkan the type of the file descriptor, or are prepared to deal with the system-defined operation failures resulting from using the wrong type.
     * 
     * 
     * 
Some external semaphore handle types can only be shared within the same underlying physical device and/or the same driver version, as defined in the following table:
     * 
     * 
External semaphore handle types compatibility
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
Handle type
{@link VkPhysicalDeviceIDProperties}{@code ::driverUUID}
{@link VkPhysicalDeviceIDProperties}{@code ::deviceUUID}
{@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT}
Must match
Must match
{@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT}
Must match
Must match
{@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT}
Must match
Must match
{@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT}
Must match
Must match
{@link #VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT}
No restriction
No restriction
     * 
     * 
See Also
     * 
     * 
{@link VkImportSemaphoreFdInfoKHR}, {@link VkImportSemaphoreWin32HandleInfoKHR}, {@link VkPhysicalDeviceExternalSemaphoreInfo}, {@link VkSemaphoreGetFdInfoKHR}, {@link VkSemaphoreGetWin32HandleInfoKHR}
     */
    public static final int
        VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT        = 0x1,
        VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT     = 0x2,
        VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x4,
        VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT      = 0x8,
        VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT      = 0x8,
        VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT          = 0x10;

    /**
     * VkExternalSemaphoreFeatureFlagBits - Bitfield describing features of an external semaphore handle type
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT} specifies that handles of this type can be exported from Vulkan semaphore objects.
     * 
{@link #VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT} specifies that handles of this type can be imported as Vulkan semaphore objects.
     * 
     */
    public static final int
        VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x1,
        VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x2;

    /** The API version number for Vulkan 1.1. */
    public static final int VK_API_VERSION_1_1 = VK_MAKE_VERSION(1, 1, 0);

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

    // --- [ vkEnumerateInstanceVersion ] ---

    /** Unsafe version of: {@link #vkEnumerateInstanceVersion EnumerateInstanceVersion} */
    public static int nvkEnumerateInstanceVersion(long pApiVersion) {
        long __functionAddress = VK.getGlobalCommands().vkEnumerateInstanceVersion;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPI(pApiVersion, __functionAddress);
    }

    /**
     * Query instance-level version before instance creation.
     * 
     * 
C Specification
     * 
     * 
To query the version of instance-level functionality supported by the implementation, call:
     * 
     * 

     * VkResult vkEnumerateInstanceVersion(
     *     uint32_t*                                   pApiVersion);
     * 
     * 
Description
     * 
     * 
Note
     * 
     * 
The intended behaviour of {@link #vkEnumerateInstanceVersion EnumerateInstanceVersion} is that an implementation should not need to perform memory allocations and should unconditionally return {@link VK10#VK_SUCCESS SUCCESS}. The loader, and any enabled layers, may return {@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY} in the case of a failed memory allocation.
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code pApiVersion} must be a valid pointer to a {@code uint32_t} value
     * 
     * 
     * 
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}
     * 
     * 
     *
     * @param pApiVersion a pointer to a {@code uint32_t}, which is the version of Vulkan supported by instance-level functionality, encoded as described in Version Numbers.
     */
    @NativeType("VkResult")
    public static int vkEnumerateInstanceVersion(@NativeType("uint32_t *") IntBuffer pApiVersion) {
        if (CHECKS) {
            check(pApiVersion, 1);
        }
        return nvkEnumerateInstanceVersion(memAddress(pApiVersion));
    }

    // --- [ vkBindBufferMemory2 ] ---

    /**
     * Unsafe version of: {@link #vkBindBufferMemory2 BindBufferMemory2}
     *
     * @param bindInfoCount the number of elements in {@code pBindInfos}.
     */
    public static int nvkBindBufferMemory2(VkDevice device, int bindInfoCount, long pBindInfos) {
        long __functionAddress = device.getCapabilities().vkBindBufferMemory2;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(device.address(), bindInfoCount, pBindInfos, __functionAddress);
    }

    /**
     * Bind device memory to buffer objects.
     * 
     * 
C Specification
     * 
     * 
To attach memory to buffer objects for one or more buffers at a time, call:
     * 
     * 

     * VkResult vkBindBufferMemory2(
     *     VkDevice                                    device,
     *     uint32_t                                    bindInfoCount,
     *     const VkBindBufferMemoryInfo*               pBindInfos);
     * 
     * 
or the equivalent command
     * 
     * 

     * VkResult vkBindBufferMemory2KHR(
     *     VkDevice                                    device,
     *     uint32_t                                    bindInfoCount,
     *     const VkBindBufferMemoryInfo*               pBindInfos);
     * 
     * 
Description
     * 
     * 
On some implementations, it may be more efficient to batch memory bindings into a single command.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pBindInfos} must be a valid pointer to an array of {@code bindInfoCount} valid {@link VkBindBufferMemoryInfo} structures
     * 
{@code bindInfoCount} must be greater than 0
     * 
     * 
     * 
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 KHRBufferDeviceAddress#VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkBindBufferMemoryInfo}
     *
     * @param device     the logical device that owns the buffers and memory.
     * @param pBindInfos a pointer to an array of {@code bindInfoCount} {@link VkBindBufferMemoryInfo} structures describing buffers and memory to bind.
     */
    @NativeType("VkResult")
    public static int vkBindBufferMemory2(VkDevice device, @NativeType("VkBindBufferMemoryInfo const *") VkBindBufferMemoryInfo.Buffer pBindInfos) {
        return nvkBindBufferMemory2(device, pBindInfos.remaining(), pBindInfos.address());
    }

    // --- [ vkBindImageMemory2 ] ---

    /**
     * Unsafe version of: {@link #vkBindImageMemory2 BindImageMemory2}
     *
     * @param bindInfoCount the number of elements in {@code pBindInfos}.
     */
    public static int nvkBindImageMemory2(VkDevice device, int bindInfoCount, long pBindInfos) {
        long __functionAddress = device.getCapabilities().vkBindImageMemory2;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(device.address(), bindInfoCount, pBindInfos, __functionAddress);
    }

    /**
     * Bind device memory to image objects.
     * 
     * 
C Specification
     * 
     * 
To attach memory to image objects for one or more images at a time, call:
     * 
     * 

     * VkResult vkBindImageMemory2(
     *     VkDevice                                    device,
     *     uint32_t                                    bindInfoCount,
     *     const VkBindImageMemoryInfo*                pBindInfos);
     * 
     * 
or the equivalent command
     * 
     * 

     * VkResult vkBindImageMemory2KHR(
     *     VkDevice                                    device,
     *     uint32_t                                    bindInfoCount,
     *     const VkBindImageMemoryInfo*                pBindInfos);
     * 
     * 
Description
     * 
     * 
On some implementations, it may be more efficient to batch memory bindings into a single command.
     * 
     * 
Valid Usage
     * 
     * 

     * 
If any {@link VkBindImageMemoryInfo}{@code ::image} was created with {@link #VK_IMAGE_CREATE_DISJOINT_BIT IMAGE_CREATE_DISJOINT_BIT} then all planes of {@link VkBindImageMemoryInfo}{@code ::image} must be bound individually in separate {@code pBindInfos}
     * 
{@code pBindInfos} must not refer to the same image subresource more than once
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pBindInfos} must be a valid pointer to an array of {@code bindInfoCount} valid {@link VkBindImageMemoryInfo} structures
     * 
{@code bindInfoCount} must be greater than 0
     * 
     * 
     * 
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 VkBindImageMemoryInfo}
     *
     * @param device     the logical device that owns the images and memory.
     * @param pBindInfos a pointer to an array of {@link VkBindImageMemoryInfo} structures, describing images and memory to bind.
     */
    @NativeType("VkResult")
    public static int vkBindImageMemory2(VkDevice device, @NativeType("VkBindImageMemoryInfo const *") VkBindImageMemoryInfo.Buffer pBindInfos) {
        return nvkBindImageMemory2(device, pBindInfos.remaining(), pBindInfos.address());
    }

    // --- [ vkGetDeviceGroupPeerMemoryFeatures ] ---

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

    /**
     * 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 vkGetDeviceGroupPeerMemoryFeatures(
     *     VkDevice                                    device,
     *     uint32_t                                    heapIndex,
     *     uint32_t                                    localDeviceIndex,
     *     uint32_t                                    remoteDeviceIndex,
     *     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetDeviceGroupPeerMemoryFeaturesKHR(
     *     VkDevice                                    device,
     *     uint32_t                                    heapIndex,
     *     uint32_t                                    localDeviceIndex,
     *     uint32_t                                    remoteDeviceIndex,
     *     VkPeerMemoryFeatureFlags*                   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 {@code remoteDeviceIndex}
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pPeerMemoryFeatures} must be a valid pointer to a {@code VkPeerMemoryFeatureFlags} value
     * 
     *
     * @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 {@code VkPeerMemoryFeatureFlags} bitmask indicating which types of memory accesses are supported for the combination of heap, local, and remote devices.
     */
    public static void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, @NativeType("uint32_t") int heapIndex, @NativeType("uint32_t") int localDeviceIndex, @NativeType("uint32_t") int remoteDeviceIndex, @NativeType("VkPeerMemoryFeatureFlags *") IntBuffer pPeerMemoryFeatures) {
        if (CHECKS) {
            check(pPeerMemoryFeatures, 1);
        }
        nvkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, memAddress(pPeerMemoryFeatures));
    }

    // --- [ vkCmdSetDeviceMask ] ---

    /**
     * Modify device mask of a command buffer.
     * 
     * 
C Specification
     * 
     * 
To update the current device mask of a command buffer, call:
     * 
     * 

     * void vkCmdSetDeviceMask(
     *     VkCommandBuffer                             commandBuffer,
     *     uint32_t                                    deviceMask);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkCmdSetDeviceMaskKHR(
     *     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, except commands beginning a render pass instance, commands transitioning to the next subpass in the render pass instance, and commands ending a render pass instance, which always execute on the set of physical devices whose bit indices are included in the {@code deviceMask} member of the {@link VkDeviceGroupRenderPassBeginInfo} structure passed to the command beginning the corresponding render pass instance.
     * 
     * 
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 VkDeviceGroupCommandBufferBeginInfo}{@code ::deviceMask} value when the command buffer began recording
     * 
If {@code vkCmdSetDeviceMask} is called inside a render pass instance, {@code deviceMask} must not include any set bits that were not in the {@link VkDeviceGroupRenderPassBeginInfo}{@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
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 vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, @NativeType("uint32_t") int deviceMask) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdSetDeviceMask;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPV(commandBuffer.address(), deviceMask, __functionAddress);
    }

    // --- [ vkCmdDispatchBase ] ---

    /**
     * Dispatch compute work items with non-zero base values for the workgroup IDs.
     * 
     * 
C Specification
     * 
     * 
To record a dispatch using non-zero base values for the components of {@code WorkgroupId}, call:
     * 
     * 

     * void vkCmdDispatchBase(
     *     VkCommandBuffer                             commandBuffer,
     *     uint32_t                                    baseGroupX,
     *     uint32_t                                    baseGroupY,
     *     uint32_t                                    baseGroupZ,
     *     uint32_t                                    groupCountX,
     *     uint32_t                                    groupCountY,
     *     uint32_t                                    groupCountZ);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkCmdDispatchBaseKHR(
     *     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 × groupCountY × groupCountZ local workgroups is assembled, with {@code WorkgroupId} values ranging from [baseGroup*, baseGroup* + groupCount*) in each component. {@link VK10#vkCmdDispatch CmdDispatch} is equivalent to {@code vkCmdDispatchBase(0,0,0,groupCountX,groupCountY,groupCountZ)}.
     * 
     * 
Valid Usage
     * 
     * 

     * 
If a {@code VkSampler} created with {@code magFilter} or {@code minFilter} equal to {@link VK10#VK_FILTER_LINEAR FILTER_LINEAR} and {@code compareEnable} equal to {@link VK10#VK_FALSE FALSE} is used to sample a {@code VkImageView} as a result of this command, then the image view’s format features must contain {@link VK10#VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT}
     * 
If a {@code VkSampler} created with {@code mipmapMode} equal to {@link VK10#VK_SAMPLER_MIPMAP_MODE_LINEAR SAMPLER_MIPMAP_MODE_LINEAR} and {@code compareEnable} equal to {@link VK10#VK_FALSE FALSE} is used to sample a {@code VkImageView} as a result of this command, then the image view’s format features must contain {@link VK10#VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT}
     * 
If a {@code VkImageView} is accessed using atomic operations as a result of this command, then the image view’s format features must contain {@link VK10#VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT}
     * 
If a {@code VkImageView} is sampled with {@link EXTFilterCubic#VK_FILTER_CUBIC_EXT FILTER_CUBIC_EXT} as a result of this command, then the image view’s format features must contain {@link EXTFilterCubic#VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT}
     * 
Any {@code VkImageView} being sampled with {@link EXTFilterCubic#VK_FILTER_CUBIC_EXT FILTER_CUBIC_EXT} as a result of this command must have a {@code VkImageViewType} and format that supports cubic filtering, as specified by {@link VkFilterCubicImageViewImageFormatPropertiesEXT}{@code ::filterCubic} returned by {@code vkGetPhysicalDeviceImageFormatProperties2}
     * 
Any {@code VkImageView} being sampled with {@link EXTFilterCubic#VK_FILTER_CUBIC_EXT FILTER_CUBIC_EXT} with a reduction mode of either {@link VK12#VK_SAMPLER_REDUCTION_MODE_MIN SAMPLER_REDUCTION_MODE_MIN} or {@link VK12#VK_SAMPLER_REDUCTION_MODE_MAX SAMPLER_REDUCTION_MODE_MAX} as a result of this command must have a {@code VkImageViewType} and format that supports cubic filtering together with minmax filtering, as specified by {@link VkFilterCubicImageViewImageFormatPropertiesEXT}{@code ::filterCubicMinmax} returned by {@code vkGetPhysicalDeviceImageFormatProperties2}
     * 
Any {@code VkImage} created with a {@link VkImageCreateInfo}{@code ::flags} containing {@link NVCornerSampledImage#VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV IMAGE_CREATE_CORNER_SAMPLED_BIT_NV} sampled as a result of this command must only be sampled using a {@code VkSamplerAddressMode} of {@link VK10#VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE}
     * 
Any {@code VkImageView} or {@code VkBufferView} being written as a storage image or storage texel buffer where the image format field of the {@code OpTypeImage} is {@code Unknown} must have image format features that support {@link KHRFormatFeatureFlags2#VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR}
     * 
Any {@code VkImageView} or {@code VkBufferView} being read as a storage image or storage texel buffer where the image format field of the {@code OpTypeImage} is {@code Unknown} must have image format features that support {@link KHRFormatFeatureFlags2#VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR}
     * 
For each set n that is statically used by the {@code VkPipeline} bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a {@code VkPipelineLayout} that is compatible for set n, with the {@code VkPipelineLayout} used to create the current {@code VkPipeline}, as described in Pipeline Layout Compatibility
     * 
If the {@code maintenance4} feature is not enabled, then for each push constant that is statically used by the {@code VkPipeline} bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a {@code VkPipelineLayout} that is compatible for push constants, with the {@code VkPipelineLayout} used to create the current {@code VkPipeline}, as described in Pipeline Layout Compatibility
     * 
Descriptors in each bound descriptor set, specified via {@code vkCmdBindDescriptorSets}, must be valid if they are statically used by the {@code VkPipeline} bound to the pipeline bind point used by this command
     * 
A valid pipeline must be bound to the pipeline bind point used by this command
     * 
If the {@code VkPipeline} object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the {@link NVInheritedViewportScissor VK_NV_inherited_viewport_scissor} extension is enabled) for {@code commandBuffer}, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
     * 
There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the {@code VkPipeline} object bound to the pipeline bind point used by this command, since that pipeline was bound
     * 
If the {@code VkPipeline} object bound to the pipeline bind point used by this command accesses a {@code VkSampler} object that uses unnormalized coordinates, that sampler must not be used to sample from any {@code VkImage} with a {@code VkImageView} of the type {@link VK10#VK_IMAGE_VIEW_TYPE_3D IMAGE_VIEW_TYPE_3D}, {@link VK10#VK_IMAGE_VIEW_TYPE_CUBE IMAGE_VIEW_TYPE_CUBE}, {@link VK10#VK_IMAGE_VIEW_TYPE_1D_ARRAY IMAGE_VIEW_TYPE_1D_ARRAY}, {@link VK10#VK_IMAGE_VIEW_TYPE_2D_ARRAY IMAGE_VIEW_TYPE_2D_ARRAY} or {@link VK10#VK_IMAGE_VIEW_TYPE_CUBE_ARRAY IMAGE_VIEW_TYPE_CUBE_ARRAY}, in any shader stage
     * 
If the {@code VkPipeline} object bound to the pipeline bind point used by this command accesses a {@code VkSampler} object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V {@code OpImageSample*} or {@code OpImageSparseSample*} instructions with {@code ImplicitLod}, {@code Dref} or {@code Proj} in their name, in any shader stage
     * 
If the {@code VkPipeline} object bound to the pipeline bind point used by this command accesses a {@code VkSampler} object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V {@code OpImageSample*} or {@code OpImageSparseSample*} instructions that includes a LOD bias or any offset values, in any shader stage
     * 
If the robust buffer access feature is not enabled, and if the {@code VkPipeline} object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
     * 
If the robust buffer access feature is not enabled, and if the {@code VkPipeline} object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, any resource accessed by the {@code VkPipeline} object bound to the pipeline bind point used by this command must not be a protected resource
     * 
If a {@code VkImageView} is accessed using {@code OpImageWrite} as a result of this command, then the {@code Type} of the {@code Texel} operand of that instruction must have at least as many components as the image view’s format
     * 
If a {@code VkBufferView} is accessed using {@code OpImageWrite} as a result of this command, then the {@code Type} of the {@code Texel} operand of that instruction must have at least as many components as the buffer view’s format
     * 
If a {@code VkImageView} with a {@code VkFormat} that has a 64-bit component width is accessed as a result of this command, the {@code SampledType} of the {@code OpTypeImage} operand of that instruction must have a {@code Width} of 64
     * 
If a {@code VkImageView} with a {@code VkFormat} that has a component width less than 64-bit is accessed as a result of this command, the {@code SampledType} of the {@code OpTypeImage} operand of that instruction must have a {@code Width} of 32
     * 
If a {@code VkBufferView} with a {@code VkFormat} that has a 64-bit component width is accessed as a result of this command, the {@code SampledType} of the {@code OpTypeImage} operand of that instruction must have a {@code Width} of 64
     * 
If a {@code VkBufferView} with a {@code VkFormat} that has a component width less than 64-bit is accessed as a result of this command, the {@code SampledType} of the {@code OpTypeImage} operand of that instruction must have a {@code Width} of 32
     * 
If the {@code sparseImageInt64Atomics} feature is not enabled, {@code VkImage} objects created with the {@link VK10#VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT IMAGE_CREATE_SPARSE_RESIDENCY_BIT} flag must not be accessed by atomic instructions through an {@code OpTypeImage} with a {@code SampledType} with a {@code Width} of 64 by this command
     * 
If the {@code sparseImageInt64Atomics} feature is not enabled, {@code VkBuffer} objects created with the {@link VK10#VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT BUFFER_CREATE_SPARSE_RESIDENCY_BIT} flag must not be accessed by atomic instructions through an {@code OpTypeImage} with a {@code SampledType} with a {@code Width} of 64 by this command
     * 
     * 
     * 

     * 
If {@code commandBuffer} is a protected command buffer and {@code protectedNoFault} is not supported, any resource written to by the {@code VkPipeline} object bound to the pipeline bind point used by this command must not be an unprotected resource
     * 
If {@code commandBuffer} is a protected command buffer and {@code protectedNoFault} is not supported, pipeline stages other than the framebuffer-space and compute stages in the {@code VkPipeline} object bound to the pipeline bind point used by this command must not write to any resource
     * 
If any of the shader stages of the {@code VkPipeline} bound to the pipeline bind point used by this command uses the RayQueryKHR capability, then {@code commandBuffer} must not be a protected command buffer
     * 
{@code baseGroupX} must be less than {@link VkPhysicalDeviceLimits}{@code ::maxComputeWorkGroupCount}[0]
     * 
{@code baseGroupY} must be less than {@link VkPhysicalDeviceLimits}{@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 bound compute pipeline must have been created with the {@link #VK_PIPELINE_CREATE_DISPATCH_BASE PIPELINE_CREATE_DISPATCH_BASE} 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
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 vkCmdDispatchBase(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().vkCmdDispatchBase;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPV(commandBuffer.address(), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, __functionAddress);
    }

    // --- [ vkEnumeratePhysicalDeviceGroups ] ---

    /**
     * Unsafe version of: {@link #vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups}
     *
     * @param pPhysicalDeviceGroupCount a pointer to an integer related to the number of device groups available or queried, as described below.
     */
    public static int nvkEnumeratePhysicalDeviceGroups(VkInstance instance, long pPhysicalDeviceGroupCount, long pPhysicalDeviceGroupProperties) {
        long __functionAddress = instance.getCapabilities().vkEnumeratePhysicalDeviceGroups;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPPI(instance.address(), pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, __functionAddress);
    }

    /**
     * Enumerates groups of physical devices that can be used to create a single logical device.
     * 
     * 
C Specification
     * 
     * 
To retrieve a list of the device groups present in the system, call:
     * 
     * 

     * VkResult vkEnumeratePhysicalDeviceGroups(
     *     VkInstance                                  instance,
     *     uint32_t*                                   pPhysicalDeviceGroupCount,
     *     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
     * 
     * 
or the equivalent command
     * 
     * 

     * VkResult vkEnumeratePhysicalDeviceGroupsKHR(
     *     VkInstance                                  instance,
     *     uint32_t*                                   pPhysicalDeviceGroupCount,
     *     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
     * 
     * 
Description
     * 
     * 
If {@code pPhysicalDeviceGroupProperties} is {@code NULL}, then the number of device groups available is returned in {@code pPhysicalDeviceGroupCount}. Otherwise, {@code pPhysicalDeviceGroupCount} must point to a variable set by the user to the number of elements in the {@code pPhysicalDeviceGroupProperties} array, and on return the variable is overwritten with the number of structures actually written to {@code pPhysicalDeviceGroupProperties}. If {@code pPhysicalDeviceGroupCount} is less than the number of device groups available, at most {@code pPhysicalDeviceGroupCount} structures will be written, and {@link VK10#VK_INCOMPLETE INCOMPLETE} will be returned instead of {@link VK10#VK_SUCCESS SUCCESS}, to indicate that not all the available device groups were returned.
     * 
     * 
Every physical device must be in exactly one device group.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code instance} must be a valid {@code VkInstance} handle
     * 
{@code pPhysicalDeviceGroupCount} must be a valid pointer to a {@code uint32_t} value
     * 
If the value referenced by {@code pPhysicalDeviceGroupCount} is not 0, and {@code pPhysicalDeviceGroupProperties} is not {@code NULL}, {@code pPhysicalDeviceGroupProperties} must be a valid pointer to an array of {@code pPhysicalDeviceGroupCount} {@link VkPhysicalDeviceGroupProperties} structures
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
{@link VK10#VK_INCOMPLETE INCOMPLETE}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
{@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
     * 
{@link VK10#VK_ERROR_INITIALIZATION_FAILED ERROR_INITIALIZATION_FAILED}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPhysicalDeviceGroupProperties}
     *
     * @param instance                       a handle to a Vulkan instance previously created with {@link VK10#vkCreateInstance CreateInstance}.
     * @param pPhysicalDeviceGroupCount      a pointer to an integer related to the number of device groups available or queried, as described below.
     * @param pPhysicalDeviceGroupProperties either {@code NULL} or a pointer to an array of {@link VkPhysicalDeviceGroupProperties} structures.
     */
    @NativeType("VkResult")
    public static int vkEnumeratePhysicalDeviceGroups(VkInstance instance, @NativeType("uint32_t *") IntBuffer pPhysicalDeviceGroupCount, @Nullable @NativeType("VkPhysicalDeviceGroupProperties *") VkPhysicalDeviceGroupProperties.Buffer pPhysicalDeviceGroupProperties) {
        if (CHECKS) {
            check(pPhysicalDeviceGroupCount, 1);
            checkSafe(pPhysicalDeviceGroupProperties, pPhysicalDeviceGroupCount.get(pPhysicalDeviceGroupCount.position()));
        }
        return nvkEnumeratePhysicalDeviceGroups(instance, memAddress(pPhysicalDeviceGroupCount), memAddressSafe(pPhysicalDeviceGroupProperties));
    }

    // --- [ vkGetImageMemoryRequirements2 ] ---

    /** Unsafe version of: {@link #vkGetImageMemoryRequirements2 GetImageMemoryRequirements2} */
    public static void nvkGetImageMemoryRequirements2(VkDevice device, long pInfo, long pMemoryRequirements) {
        long __functionAddress = device.getCapabilities().vkGetImageMemoryRequirements2;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPV(device.address(), pInfo, pMemoryRequirements, __functionAddress);
    }

    /**
     * Returns the memory requirements for specified Vulkan object.
     * 
     * 
C Specification
     * 
     * 
To determine the memory requirements for an image resource, call:
     * 
     * 

     * void vkGetImageMemoryRequirements2(
     *     VkDevice                                    device,
     *     const VkImageMemoryRequirementsInfo2*       pInfo,
     *     VkMemoryRequirements2*                      pMemoryRequirements);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetImageMemoryRequirements2KHR(
     *     VkDevice                                    device,
     *     const VkImageMemoryRequirementsInfo2*       pInfo,
     *     VkMemoryRequirements2*                      pMemoryRequirements);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pInfo} must be a valid pointer to a valid {@link VkImageMemoryRequirementsInfo2} structure
     * 
{@code pMemoryRequirements} must be a valid pointer to a {@link VkMemoryRequirements2} structure
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkImageMemoryRequirementsInfo2}, {@link VkMemoryRequirements2}
     *
     * @param device              the logical device that owns the image.
     * @param pInfo               a pointer to a {@link VkImageMemoryRequirementsInfo2} structure containing parameters required for the memory requirements query.
     * @param pMemoryRequirements a pointer to a {@link VkMemoryRequirements2} structure in which the memory requirements of the image object are returned.
     */
    public static void vkGetImageMemoryRequirements2(VkDevice device, @NativeType("VkImageMemoryRequirementsInfo2 const *") VkImageMemoryRequirementsInfo2 pInfo, @NativeType("VkMemoryRequirements2 *") VkMemoryRequirements2 pMemoryRequirements) {
        nvkGetImageMemoryRequirements2(device, pInfo.address(), pMemoryRequirements.address());
    }

    // --- [ vkGetBufferMemoryRequirements2 ] ---

    /** Unsafe version of: {@link #vkGetBufferMemoryRequirements2 GetBufferMemoryRequirements2} */
    public static void nvkGetBufferMemoryRequirements2(VkDevice device, long pInfo, long pMemoryRequirements) {
        long __functionAddress = device.getCapabilities().vkGetBufferMemoryRequirements2;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPV(device.address(), pInfo, pMemoryRequirements, __functionAddress);
    }

    /**
     * Returns the memory requirements for specified Vulkan object.
     * 
     * 
C Specification
     * 
     * 
To determine the memory requirements for a buffer resource, call:
     * 
     * 

     * void vkGetBufferMemoryRequirements2(
     *     VkDevice                                    device,
     *     const VkBufferMemoryRequirementsInfo2*      pInfo,
     *     VkMemoryRequirements2*                      pMemoryRequirements);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetBufferMemoryRequirements2KHR(
     *     VkDevice                                    device,
     *     const VkBufferMemoryRequirementsInfo2*      pInfo,
     *     VkMemoryRequirements2*                      pMemoryRequirements);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pInfo} must be a valid pointer to a valid {@link VkBufferMemoryRequirementsInfo2} structure
     * 
{@code pMemoryRequirements} must be a valid pointer to a {@link VkMemoryRequirements2} structure
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkBufferMemoryRequirementsInfo2}, {@link VkMemoryRequirements2}
     *
     * @param device              the logical device that owns the buffer.
     * @param pInfo               a pointer to a {@link VkBufferMemoryRequirementsInfo2} structure containing parameters required for the memory requirements query.
     * @param pMemoryRequirements a pointer to a {@link VkMemoryRequirements2} structure in which the memory requirements of the buffer object are returned.
     */
    public static void vkGetBufferMemoryRequirements2(VkDevice device, @NativeType("VkBufferMemoryRequirementsInfo2 const *") VkBufferMemoryRequirementsInfo2 pInfo, @NativeType("VkMemoryRequirements2 *") VkMemoryRequirements2 pMemoryRequirements) {
        nvkGetBufferMemoryRequirements2(device, pInfo.address(), pMemoryRequirements.address());
    }

    // --- [ vkGetImageSparseMemoryRequirements2 ] ---

    /**
     * Unsafe version of: {@link #vkGetImageSparseMemoryRequirements2 GetImageSparseMemoryRequirements2}
     *
     * @param pSparseMemoryRequirementCount a pointer to an integer related to the number of sparse memory requirements available or queried, as described below.
     */
    public static void nvkGetImageSparseMemoryRequirements2(VkDevice device, long pInfo, long pSparseMemoryRequirementCount, long pSparseMemoryRequirements) {
        long __functionAddress = device.getCapabilities().vkGetImageSparseMemoryRequirements2;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPPV(device.address(), pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, __functionAddress);
    }

    /**
     * Query the memory requirements for a sparse image.
     * 
     * 
C Specification
     * 
     * 
To query sparse memory requirements for an image, call:
     * 
     * 

     * void vkGetImageSparseMemoryRequirements2(
     *     VkDevice                                    device,
     *     const VkImageSparseMemoryRequirementsInfo2* pInfo,
     *     uint32_t*                                   pSparseMemoryRequirementCount,
     *     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetImageSparseMemoryRequirements2KHR(
     *     VkDevice                                    device,
     *     const VkImageSparseMemoryRequirementsInfo2* pInfo,
     *     uint32_t*                                   pSparseMemoryRequirementCount,
     *     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pInfo} must be a valid pointer to a valid {@link VkImageSparseMemoryRequirementsInfo2} structure
     * 
{@code pSparseMemoryRequirementCount} must be a valid pointer to a {@code uint32_t} value
     * 
If the value referenced by {@code pSparseMemoryRequirementCount} is not 0, and {@code pSparseMemoryRequirements} is not {@code NULL}, {@code pSparseMemoryRequirements} must be a valid pointer to an array of {@code pSparseMemoryRequirementCount} {@link VkSparseImageMemoryRequirements2} structures
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkImageSparseMemoryRequirementsInfo2}, {@link VkSparseImageMemoryRequirements2}
     *
     * @param device                        the logical device that owns the image.
     * @param pInfo                         a pointer to a {@link VkImageSparseMemoryRequirementsInfo2} structure containing parameters required for the memory requirements query.
     * @param pSparseMemoryRequirementCount a pointer to an integer related to the number of sparse memory requirements available or queried, as described below.
     * @param pSparseMemoryRequirements     either {@code NULL} or a pointer to an array of {@link VkSparseImageMemoryRequirements2} structures.
     */
    public static void vkGetImageSparseMemoryRequirements2(VkDevice device, @NativeType("VkImageSparseMemoryRequirementsInfo2 const *") VkImageSparseMemoryRequirementsInfo2 pInfo, @NativeType("uint32_t *") IntBuffer pSparseMemoryRequirementCount, @Nullable @NativeType("VkSparseImageMemoryRequirements2 *") VkSparseImageMemoryRequirements2.Buffer pSparseMemoryRequirements) {
        if (CHECKS) {
            check(pSparseMemoryRequirementCount, 1);
            checkSafe(pSparseMemoryRequirements, pSparseMemoryRequirementCount.get(pSparseMemoryRequirementCount.position()));
        }
        nvkGetImageSparseMemoryRequirements2(device, pInfo.address(), memAddress(pSparseMemoryRequirementCount), memAddressSafe(pSparseMemoryRequirements));
    }

    // --- [ vkGetPhysicalDeviceFeatures2 ] ---

    /** Unsafe version of: {@link #vkGetPhysicalDeviceFeatures2 GetPhysicalDeviceFeatures2} */
    public static void nvkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, long pFeatures) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceFeatures2;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPV(physicalDevice.address(), pFeatures, __functionAddress);
    }

    /**
     * Reports capabilities of a physical device.
     * 
     * 
C Specification
     * 
     * 
To query supported features defined by the core or extensions, call:
     * 
     * 

     * void vkGetPhysicalDeviceFeatures2(
     *     VkPhysicalDevice                            physicalDevice,
     *     VkPhysicalDeviceFeatures2*                  pFeatures);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetPhysicalDeviceFeatures2KHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     VkPhysicalDeviceFeatures2*                  pFeatures);
     * 
     * 
Description
     * 
     * 
Each structure in {@code pFeatures} and its {@code pNext} chain contains members corresponding to fine-grained features. {@code vkGetPhysicalDeviceFeatures2} writes each member to a boolean value indicating whether that feature is supported.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code pFeatures} must be a valid pointer to a {@link VkPhysicalDeviceFeatures2} structure
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPhysicalDeviceFeatures2}
     *
     * @param physicalDevice the physical device from which to query the supported features.
     * @param pFeatures      a pointer to a {@link VkPhysicalDeviceFeatures2} structure in which the physical device features are returned.
     */
    public static void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, @NativeType("VkPhysicalDeviceFeatures2 *") VkPhysicalDeviceFeatures2 pFeatures) {
        nvkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures.address());
    }

    // --- [ vkGetPhysicalDeviceProperties2 ] ---

    /** Unsafe version of: {@link #vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2} */
    public static void nvkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, long pProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceProperties2;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPV(physicalDevice.address(), pProperties, __functionAddress);
    }

    /**
     * Returns properties of a physical device.
     * 
     * 
C Specification
     * 
     * 
To query general properties of physical devices once enumerated, call:
     * 
     * 

     * void vkGetPhysicalDeviceProperties2(
     *     VkPhysicalDevice                            physicalDevice,
     *     VkPhysicalDeviceProperties2*                pProperties);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetPhysicalDeviceProperties2KHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     VkPhysicalDeviceProperties2*                pProperties);
     * 
     * 
Description
     * 
     * 
Each structure in {@code pProperties} and its {@code pNext} chain contains members corresponding to implementation-dependent properties, behaviors, or limits. {@code vkGetPhysicalDeviceProperties2} fills in each member to specify the corresponding value for the implementation.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code pProperties} must be a valid pointer to a {@link VkPhysicalDeviceProperties2} structure
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPhysicalDeviceProperties2}
     *
     * @param physicalDevice the handle to the physical device whose properties will be queried.
     * @param pProperties    a pointer to a {@link VkPhysicalDeviceProperties2} structure in which properties are returned.
     */
    public static void vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, @NativeType("VkPhysicalDeviceProperties2 *") VkPhysicalDeviceProperties2 pProperties) {
        nvkGetPhysicalDeviceProperties2(physicalDevice, pProperties.address());
    }

    // --- [ vkGetPhysicalDeviceFormatProperties2 ] ---

    /** Unsafe version of: {@link #vkGetPhysicalDeviceFormatProperties2 GetPhysicalDeviceFormatProperties2} */
    public static void nvkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, int format, long pFormatProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceFormatProperties2;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPV(physicalDevice.address(), format, pFormatProperties, __functionAddress);
    }

    /**
     * Lists physical device’s format capabilities.
     * 
     * 
C Specification
     * 
     * 
To query supported format features which are properties of the physical device, call:
     * 
     * 

     * void vkGetPhysicalDeviceFormatProperties2(
     *     VkPhysicalDevice                            physicalDevice,
     *     VkFormat                                    format,
     *     VkFormatProperties2*                        pFormatProperties);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetPhysicalDeviceFormatProperties2KHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     VkFormat                                    format,
     *     VkFormatProperties2*                        pFormatProperties);
     * 
     * 
Description
     * 
     * 
{@code vkGetPhysicalDeviceFormatProperties2} behaves similarly to {@link VK10#vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties}, with the ability to return extended information in a {@code pNext} chain of output structures.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code format} must be a valid {@code VkFormat} value
     * 
{@code pFormatProperties} must be a valid pointer to a {@link VkFormatProperties2} structure
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkFormatProperties2}
     *
     * @param physicalDevice    the physical device from which to query the format properties.
     * @param format            the format whose properties are queried.
     * @param pFormatProperties a pointer to a {@link VkFormatProperties2} structure in which physical device properties for {@code format} are returned.
     */
    public static void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, @NativeType("VkFormat") int format, @NativeType("VkFormatProperties2 *") VkFormatProperties2 pFormatProperties) {
        nvkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties.address());
    }

    // --- [ vkGetPhysicalDeviceImageFormatProperties2 ] ---

    /** Unsafe version of: {@link #vkGetPhysicalDeviceImageFormatProperties2 GetPhysicalDeviceImageFormatProperties2} */
    public static int nvkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, long pImageFormatInfo, long pImageFormatProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceImageFormatProperties2;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPPI(physicalDevice.address(), pImageFormatInfo, pImageFormatProperties, __functionAddress);
    }

    /**
     * Lists physical device’s image format capabilities.
     * 
     * 
C Specification
     * 
     * 
To query additional capabilities specific to image types, call:
     * 
     * 

     * VkResult vkGetPhysicalDeviceImageFormatProperties2(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
     *     VkImageFormatProperties2*                   pImageFormatProperties);
     * 
     * 
or the equivalent command
     * 
     * 

     * VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
     *     VkImageFormatProperties2*                   pImageFormatProperties);
     * 
     * 
Description
     * 
     * 
{@code vkGetPhysicalDeviceImageFormatProperties2} behaves similarly to {@link VK10#vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties}, with the ability to return extended information in a {@code pNext} chain of output structures.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code pImageFormatInfo} must be a valid pointer to a valid {@link VkPhysicalDeviceImageFormatInfo2} structure
     * 
{@code pImageFormatProperties} must be a valid pointer to a {@link VkImageFormatProperties2} 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}
     * 
{@link VK10#VK_ERROR_FORMAT_NOT_SUPPORTED ERROR_FORMAT_NOT_SUPPORTED}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkImageFormatProperties2}, {@link VkPhysicalDeviceImageFormatInfo2}
     *
     * @param physicalDevice         the physical device from which to query the image capabilities.
     * @param pImageFormatInfo       a pointer to a {@link VkPhysicalDeviceImageFormatInfo2} structure describing the parameters that would be consumed by {@link VK10#vkCreateImage CreateImage}.
     * @param pImageFormatProperties a pointer to a {@link VkImageFormatProperties2} structure in which capabilities are returned.
     */
    @NativeType("VkResult")
    public static int vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, @NativeType("VkPhysicalDeviceImageFormatInfo2 const *") VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo, @NativeType("VkImageFormatProperties2 *") VkImageFormatProperties2 pImageFormatProperties) {
        return nvkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo.address(), pImageFormatProperties.address());
    }

    // --- [ vkGetPhysicalDeviceQueueFamilyProperties2 ] ---

    /**
     * Unsafe version of: {@link #vkGetPhysicalDeviceQueueFamilyProperties2 GetPhysicalDeviceQueueFamilyProperties2}
     *
     * @param pQueueFamilyPropertyCount a pointer to an integer related to the number of queue families available or queried, as described in {@link VK10#vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties}.
     */
    public static void nvkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, long pQueueFamilyPropertyCount, long pQueueFamilyProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceQueueFamilyProperties2;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPV(physicalDevice.address(), pQueueFamilyPropertyCount, pQueueFamilyProperties, __functionAddress);
    }

    /**
     * Reports properties of the queues of the specified physical device.
     * 
     * 
C Specification
     * 
     * 
To query properties of queues available on a physical device, call:
     * 
     * 

     * void vkGetPhysicalDeviceQueueFamilyProperties2(
     *     VkPhysicalDevice                            physicalDevice,
     *     uint32_t*                                   pQueueFamilyPropertyCount,
     *     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     uint32_t*                                   pQueueFamilyPropertyCount,
     *     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
     * 
     * 
Description
     * 
     * 
{@code vkGetPhysicalDeviceQueueFamilyProperties2} behaves similarly to {@link VK10#vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties}, with the ability to return extended information in a {@code pNext} chain of output structures.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code pQueueFamilyPropertyCount} must be a valid pointer to a {@code uint32_t} value
     * 
If the value referenced by {@code pQueueFamilyPropertyCount} is not 0, and {@code pQueueFamilyProperties} is not {@code NULL}, {@code pQueueFamilyProperties} must be a valid pointer to an array of {@code pQueueFamilyPropertyCount} {@link VkQueueFamilyProperties2} structures
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkQueueFamilyProperties2}
     *
     * @param physicalDevice            the handle to the physical device whose properties will be queried.
     * @param pQueueFamilyPropertyCount a pointer to an integer related to the number of queue families available or queried, as described in {@link VK10#vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties}.
     * @param pQueueFamilyProperties    either {@code NULL} or a pointer to an array of {@link VkQueueFamilyProperties2} structures.
     */
    public static void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, @NativeType("uint32_t *") IntBuffer pQueueFamilyPropertyCount, @Nullable @NativeType("VkQueueFamilyProperties2 *") VkQueueFamilyProperties2.Buffer pQueueFamilyProperties) {
        if (CHECKS) {
            check(pQueueFamilyPropertyCount, 1);
            checkSafe(pQueueFamilyProperties, pQueueFamilyPropertyCount.get(pQueueFamilyPropertyCount.position()));
        }
        nvkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, memAddress(pQueueFamilyPropertyCount), memAddressSafe(pQueueFamilyProperties));
    }

    // --- [ vkGetPhysicalDeviceMemoryProperties2 ] ---

    /** Unsafe version of: {@link #vkGetPhysicalDeviceMemoryProperties2 GetPhysicalDeviceMemoryProperties2} */
    public static void nvkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, long pMemoryProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceMemoryProperties2;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPV(physicalDevice.address(), pMemoryProperties, __functionAddress);
    }

    /**
     * Reports memory information for the specified physical device.
     * 
     * 
C Specification
     * 
     * 
To query memory properties, call:
     * 
     * 

     * void vkGetPhysicalDeviceMemoryProperties2(
     *     VkPhysicalDevice                            physicalDevice,
     *     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetPhysicalDeviceMemoryProperties2KHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
     * 
     * 
Description
     * 
     * 
{@code vkGetPhysicalDeviceMemoryProperties2} behaves similarly to {@link VK10#vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties}, with the ability to return extended information in a {@code pNext} chain of output structures.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code pMemoryProperties} must be a valid pointer to a {@link VkPhysicalDeviceMemoryProperties2} structure
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPhysicalDeviceMemoryProperties2}
     *
     * @param physicalDevice    the handle to the device to query.
     * @param pMemoryProperties a pointer to a {@link VkPhysicalDeviceMemoryProperties2} structure in which the properties are returned.
     */
    public static void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, @NativeType("VkPhysicalDeviceMemoryProperties2 *") VkPhysicalDeviceMemoryProperties2 pMemoryProperties) {
        nvkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties.address());
    }

    // --- [ vkGetPhysicalDeviceSparseImageFormatProperties2 ] ---

    /**
     * Unsafe version of: {@link #vkGetPhysicalDeviceSparseImageFormatProperties2 GetPhysicalDeviceSparseImageFormatProperties2}
     *
     * @param pPropertyCount a pointer to an integer related to the number of sparse format properties available or queried, as described below.
     */
    public static void nvkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, long pFormatInfo, long pPropertyCount, long pProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceSparseImageFormatProperties2;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPPV(physicalDevice.address(), pFormatInfo, pPropertyCount, pProperties, __functionAddress);
    }

    /**
     * Retrieve properties of an image format applied to sparse images.
     * 
     * 
C Specification
     * 
     * 
{@code vkGetPhysicalDeviceSparseImageFormatProperties2} returns an array of {@link VkSparseImageFormatProperties2}. Each element will describe properties for one set of image aspects that are bound simultaneously in the image. This is usually one element for each aspect in the image, but for interleaved depth/stencil images there is only one element describing the combined aspects.
     * 
     * 

     * void vkGetPhysicalDeviceSparseImageFormatProperties2(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
     *     uint32_t*                                   pPropertyCount,
     *     VkSparseImageFormatProperties2*             pProperties);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
     *     uint32_t*                                   pPropertyCount,
     *     VkSparseImageFormatProperties2*             pProperties);
     * 
     * 
Description
     * 
     * 
{@code vkGetPhysicalDeviceSparseImageFormatProperties2} behaves identically to {@link VK10#vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties}, with the ability to return extended information by adding extending structures to the {@code pNext} chain of its {@code pProperties} parameter.
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code pFormatInfo} must be a valid pointer to a valid {@link VkPhysicalDeviceSparseImageFormatInfo2} structure
     * 
{@code pPropertyCount} must be a valid pointer to a {@code uint32_t} value
     * 
If the value referenced by {@code pPropertyCount} is not 0, and {@code pProperties} is not {@code NULL}, {@code pProperties} must be a valid pointer to an array of {@code pPropertyCount} {@link VkSparseImageFormatProperties2} structures
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPhysicalDeviceSparseImageFormatInfo2}, {@link VkSparseImageFormatProperties2}
     *
     * @param physicalDevice the physical device from which to query the sparse image format properties.
     * @param pFormatInfo    a pointer to a {@link VkPhysicalDeviceSparseImageFormatInfo2} structure containing input parameters to the command.
     * @param pPropertyCount a pointer to an integer related to the number of sparse format properties available or queried, as described below.
     * @param pProperties    either {@code NULL} or a pointer to an array of {@link VkSparseImageFormatProperties2} structures.
     */
    public static void vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, @NativeType("VkPhysicalDeviceSparseImageFormatInfo2 const *") VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo, @NativeType("uint32_t *") IntBuffer pPropertyCount, @Nullable @NativeType("VkSparseImageFormatProperties2 *") VkSparseImageFormatProperties2.Buffer pProperties) {
        if (CHECKS) {
            check(pPropertyCount, 1);
            checkSafe(pProperties, pPropertyCount.get(pPropertyCount.position()));
        }
        nvkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo.address(), memAddress(pPropertyCount), memAddressSafe(pProperties));
    }

    // --- [ vkTrimCommandPool ] ---

    /**
     * Trim a command pool.
     * 
     * 
C Specification
     * 
     * 
To trim a command pool, call:
     * 
     * 

     * void vkTrimCommandPool(
     *     VkDevice                                    device,
     *     VkCommandPool                               commandPool,
     *     VkCommandPoolTrimFlags                      flags);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkTrimCommandPoolKHR(
     *     VkDevice                                    device,
     *     VkCommandPool                               commandPool,
     *     VkCommandPoolTrimFlags                      flags);
     * 
     * 
Description
     * 
     * 
Trimming a command pool recycles unused memory from the command pool back to the system. Command buffers allocated from the pool are not affected by the command.
     * 
     * 
Note
     * 
     * 
This command provides applications with some control over the internal memory allocations used by command pools.
     * 
     * 
Unused memory normally arises from command buffers that have been recorded and later reset, such that they are no longer using the memory. On reset, a command buffer can return memory to its command pool, but the only way to release memory from a command pool to the system requires calling {@link VK10#vkResetCommandPool ResetCommandPool}, which cannot be executed while any command buffers from that pool are still in use. Subsequent recording operations into command buffers will re-use this memory but since total memory requirements fluctuate over time, unused memory can accumulate.
     * 
     * 
In this situation, trimming a command pool may be useful to return unused memory back to the system, returning the total outstanding memory allocated by the pool back to a more “{@code average}” value.
     * 
     * 
Implementations utilize many internal allocation strategies that make it impossible to guarantee that all unused memory is released back to the system. For instance, an implementation of a command pool may involve allocating memory in bulk from the system and sub-allocating from that memory. In such an implementation any live command buffer that holds a reference to a bulk allocation would prevent that allocation from being freed, even if only a small proportion of the bulk allocation is in use.
     * 
     * 
In most cases trimming will result in a reduction in allocated but unused memory, but it does not guarantee the “{@code ideal}” behavior.
     * 
     * 
Trimming may be an expensive operation, and should not be called frequently. Trimming should be treated as a way to relieve memory pressure after application-known points when there exists enough unused memory that the cost of trimming is “{@code worth}” it.
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code commandPool} must be a valid {@code VkCommandPool} handle
     * 
{@code flags} must be 0
     * 
{@code commandPool} must have been created, allocated, or retrieved from {@code device}
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code commandPool} must be externally synchronized
     * 
     *
     * @param device      the logical device that owns the command pool.
     * @param commandPool the command pool to trim.
     * @param flags       reserved for future use.
     */
    public static void vkTrimCommandPool(VkDevice device, @NativeType("VkCommandPool") long commandPool, @NativeType("VkCommandPoolTrimFlags") int flags) {
        long __functionAddress = device.getCapabilities().vkTrimCommandPool;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPJV(device.address(), commandPool, flags, __functionAddress);
    }

    // --- [ vkGetDeviceQueue2 ] ---

    /** Unsafe version of: {@link #vkGetDeviceQueue2 GetDeviceQueue2} */
    public static void nvkGetDeviceQueue2(VkDevice device, long pQueueInfo, long pQueue) {
        long __functionAddress = device.getCapabilities().vkGetDeviceQueue2;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPV(device.address(), pQueueInfo, pQueue, __functionAddress);
    }

    /**
     * Get a queue handle from a device.
     * 
     * 
C Specification
     * 
     * 
To retrieve a handle to a {@code VkQueue} object with specific {@code VkDeviceQueueCreateFlags} creation flags, call:
     * 
     * 

     * void vkGetDeviceQueue2(
     *     VkDevice                                    device,
     *     const VkDeviceQueueInfo2*                   pQueueInfo,
     *     VkQueue*                                    pQueue);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pQueueInfo} must be a valid pointer to a valid {@link VkDeviceQueueInfo2} structure
     * 
{@code pQueue} must be a valid pointer to a {@code VkQueue} handle
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkDeviceQueueInfo2}
     *
     * @param device     the logical device that owns the queue.
     * @param pQueueInfo a pointer to a {@link VkDeviceQueueInfo2} structure, describing parameters of the device queue to be retrieved.
     * @param pQueue     a pointer to a {@code VkQueue} object that will be filled with the handle for the requested queue.
     */
    public static void vkGetDeviceQueue2(VkDevice device, @NativeType("VkDeviceQueueInfo2 const *") VkDeviceQueueInfo2 pQueueInfo, @NativeType("VkQueue *") PointerBuffer pQueue) {
        if (CHECKS) {
            check(pQueue, 1);
        }
        nvkGetDeviceQueue2(device, pQueueInfo.address(), memAddress(pQueue));
    }

    // --- [ vkCreateSamplerYcbcrConversion ] ---

    /** Unsafe version of: {@link #vkCreateSamplerYcbcrConversion CreateSamplerYcbcrConversion} */
    public static int nvkCreateSamplerYcbcrConversion(VkDevice device, long pCreateInfo, long pAllocator, long pYcbcrConversion) {
        long __functionAddress = device.getCapabilities().vkCreateSamplerYcbcrConversion;
        if (CHECKS) {
            check(__functionAddress);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        return callPPPPI(device.address(), pCreateInfo, pAllocator, pYcbcrConversion, __functionAddress);
    }

    /**
     * Create a new Y′CBCR conversion.
     * 
     * 
C Specification
     * 
     * 
To create a {@code VkSamplerYcbcrConversion}, call:
     * 
     * 

     * VkResult vkCreateSamplerYcbcrConversion(
     *     VkDevice                                    device,
     *     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
     *     const VkAllocationCallbacks*                pAllocator,
     *     VkSamplerYcbcrConversion*                   pYcbcrConversion);
     * 
     * 
or the equivalent command
     * 
     * 

     * VkResult vkCreateSamplerYcbcrConversionKHR(
     *     VkDevice                                    device,
     *     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
     *     const VkAllocationCallbacks*                pAllocator,
     *     VkSamplerYcbcrConversion*                   pYcbcrConversion);
     * 
     * 
Description
     * 
     * 
The interpretation of the configured sampler Y′CBCR conversion is described in more detail in the description of sampler Y′CBCR conversion in the Image Operations chapter.
     * 
     * 
Valid Usage
     * 
     * 

     * 
The sampler Y′CBCR conversion feature must be enabled
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pCreateInfo} must be a valid pointer to a valid {@link VkSamplerYcbcrConversionCreateInfo} structure
     * 
If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
     * 
{@code pYcbcrConversion} must be a valid pointer to a {@code VkSamplerYcbcrConversion} handle
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
{@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkAllocationCallbacks}, {@link VkSamplerYcbcrConversionCreateInfo}
     *
     * @param device           the logical device that creates the sampler Y′CBCR conversion.
     * @param pCreateInfo      a pointer to a {@link VkSamplerYcbcrConversionCreateInfo} structure specifying the requested sampler Y′CBCR conversion.
     * @param pAllocator       controls host memory allocation as described in the Memory Allocation chapter.
     * @param pYcbcrConversion a pointer to a {@code VkSamplerYcbcrConversion} handle in which the resulting sampler Y′CBCR conversion is returned.
     */
    @NativeType("VkResult")
    public static int vkCreateSamplerYcbcrConversion(VkDevice device, @NativeType("VkSamplerYcbcrConversionCreateInfo const *") VkSamplerYcbcrConversionCreateInfo pCreateInfo, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator, @NativeType("VkSamplerYcbcrConversion *") LongBuffer pYcbcrConversion) {
        if (CHECKS) {
            check(pYcbcrConversion, 1);
        }
        return nvkCreateSamplerYcbcrConversion(device, pCreateInfo.address(), memAddressSafe(pAllocator), memAddress(pYcbcrConversion));
    }

    // --- [ vkDestroySamplerYcbcrConversion ] ---

    /** Unsafe version of: {@link #vkDestroySamplerYcbcrConversion DestroySamplerYcbcrConversion} */
    public static void nvkDestroySamplerYcbcrConversion(VkDevice device, long ycbcrConversion, long pAllocator) {
        long __functionAddress = device.getCapabilities().vkDestroySamplerYcbcrConversion;
        if (CHECKS) {
            check(__functionAddress);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        callPJPV(device.address(), ycbcrConversion, pAllocator, __functionAddress);
    }

    /**
     * Destroy a created Y′CBCR conversion.
     * 
     * 
C Specification
     * 
     * 
To destroy a sampler Y′CBCR conversion, call:
     * 
     * 

     * void vkDestroySamplerYcbcrConversion(
     *     VkDevice                                    device,
     *     VkSamplerYcbcrConversion                    ycbcrConversion,
     *     const VkAllocationCallbacks*                pAllocator);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkDestroySamplerYcbcrConversionKHR(
     *     VkDevice                                    device,
     *     VkSamplerYcbcrConversion                    ycbcrConversion,
     *     const VkAllocationCallbacks*                pAllocator);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
If {@code ycbcrConversion} is not {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, {@code ycbcrConversion} must be a valid {@code VkSamplerYcbcrConversion} handle
     * 
If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
     * 
If {@code ycbcrConversion} is a valid handle, it must have been created, allocated, or retrieved from {@code device}
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code ycbcrConversion} must be externally synchronized
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkAllocationCallbacks}
     *
     * @param device          the logical device that destroys the Y′CBCR conversion.
     * @param ycbcrConversion the conversion to destroy.
     * @param pAllocator      controls host memory allocation as described in the Memory Allocation chapter.
     */
    public static void vkDestroySamplerYcbcrConversion(VkDevice device, @NativeType("VkSamplerYcbcrConversion") long ycbcrConversion, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator) {
        nvkDestroySamplerYcbcrConversion(device, ycbcrConversion, memAddressSafe(pAllocator));
    }

    // --- [ vkCreateDescriptorUpdateTemplate ] ---

    /** Unsafe version of: {@link #vkCreateDescriptorUpdateTemplate CreateDescriptorUpdateTemplate} */
    public static int nvkCreateDescriptorUpdateTemplate(VkDevice device, long pCreateInfo, long pAllocator, long pDescriptorUpdateTemplate) {
        long __functionAddress = device.getCapabilities().vkCreateDescriptorUpdateTemplate;
        if (CHECKS) {
            check(__functionAddress);
            VkDescriptorUpdateTemplateCreateInfo.validate(pCreateInfo);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        return callPPPPI(device.address(), pCreateInfo, pAllocator, pDescriptorUpdateTemplate, __functionAddress);
    }

    /**
     * Create a new descriptor update template.
     * 
     * 
C Specification
     * 
     * 
Updating a large {@code VkDescriptorSet} array can be an expensive operation since an application must specify one {@link VkWriteDescriptorSet} structure for each descriptor or descriptor array to update, each of which re-specifies the same state when updating the same descriptor in multiple descriptor sets. For cases when an application wishes to update the same set of descriptors in multiple descriptor sets allocated using the same {@code VkDescriptorSetLayout}, {@link #vkUpdateDescriptorSetWithTemplate UpdateDescriptorSetWithTemplate} can be used as a replacement for {@link VK10#vkUpdateDescriptorSets UpdateDescriptorSets}.
     * 
     * 
{@code VkDescriptorUpdateTemplate} allows implementations to convert a set of descriptor update operations on a single descriptor set to an internal format that, in conjunction with {@link #vkUpdateDescriptorSetWithTemplate UpdateDescriptorSetWithTemplate} or {@link KHRPushDescriptor#vkCmdPushDescriptorSetWithTemplateKHR CmdPushDescriptorSetWithTemplateKHR} , can be more efficient compared to calling {@link VK10#vkUpdateDescriptorSets UpdateDescriptorSets} or {@link KHRPushDescriptor#vkCmdPushDescriptorSetKHR CmdPushDescriptorSetKHR} . The descriptors themselves are not specified in the {@code VkDescriptorUpdateTemplate}, rather, offsets into an application provided pointer to host memory are specified, which are combined with a pointer passed to {@link #vkUpdateDescriptorSetWithTemplate UpdateDescriptorSetWithTemplate} or {@link KHRPushDescriptor#vkCmdPushDescriptorSetWithTemplateKHR CmdPushDescriptorSetWithTemplateKHR} . This allows large batches of updates to be executed without having to convert application data structures into a strictly-defined Vulkan data structure.
     * 
     * 
To create a descriptor update template, call:
     * 
     * 

     * VkResult vkCreateDescriptorUpdateTemplate(
     *     VkDevice                                    device,
     *     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
     *     const VkAllocationCallbacks*                pAllocator,
     *     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
     * 
     * 
or the equivalent command
     * 
     * 

     * VkResult vkCreateDescriptorUpdateTemplateKHR(
     *     VkDevice                                    device,
     *     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
     *     const VkAllocationCallbacks*                pAllocator,
     *     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pCreateInfo} must be a valid pointer to a valid {@link VkDescriptorUpdateTemplateCreateInfo} structure
     * 
If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
     * 
{@code pDescriptorUpdateTemplate} must be a valid pointer to a {@code VkDescriptorUpdateTemplate} handle
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
{@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkAllocationCallbacks}, {@link VkDescriptorUpdateTemplateCreateInfo}
     *
     * @param device                    the logical device that creates the descriptor update template.
     * @param pCreateInfo               a pointer to a {@link VkDescriptorUpdateTemplateCreateInfo} structure specifying the set of descriptors to update with a single call to {@link KHRPushDescriptor#vkCmdPushDescriptorSetWithTemplateKHR CmdPushDescriptorSetWithTemplateKHR} or {@link #vkUpdateDescriptorSetWithTemplate UpdateDescriptorSetWithTemplate}.
     * @param pAllocator                controls host memory allocation as described in the Memory Allocation chapter.
     * @param pDescriptorUpdateTemplate a pointer to a {@code VkDescriptorUpdateTemplate} handle in which the resulting descriptor update template object is returned.
     */
    @NativeType("VkResult")
    public static int vkCreateDescriptorUpdateTemplate(VkDevice device, @NativeType("VkDescriptorUpdateTemplateCreateInfo const *") VkDescriptorUpdateTemplateCreateInfo pCreateInfo, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator, @NativeType("VkDescriptorUpdateTemplate *") LongBuffer pDescriptorUpdateTemplate) {
        if (CHECKS) {
            check(pDescriptorUpdateTemplate, 1);
        }
        return nvkCreateDescriptorUpdateTemplate(device, pCreateInfo.address(), memAddressSafe(pAllocator), memAddress(pDescriptorUpdateTemplate));
    }

    // --- [ vkDestroyDescriptorUpdateTemplate ] ---

    /** Unsafe version of: {@link #vkDestroyDescriptorUpdateTemplate DestroyDescriptorUpdateTemplate} */
    public static void nvkDestroyDescriptorUpdateTemplate(VkDevice device, long descriptorUpdateTemplate, long pAllocator) {
        long __functionAddress = device.getCapabilities().vkDestroyDescriptorUpdateTemplate;
        if (CHECKS) {
            check(__functionAddress);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        callPJPV(device.address(), descriptorUpdateTemplate, pAllocator, __functionAddress);
    }

    /**
     * Destroy a descriptor update template object.
     * 
     * 
C Specification
     * 
     * 
To destroy a descriptor update template, call:
     * 
     * 

     * void vkDestroyDescriptorUpdateTemplate(
     *     VkDevice                                    device,
     *     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
     *     const VkAllocationCallbacks*                pAllocator);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkDestroyDescriptorUpdateTemplateKHR(
     *     VkDevice                                    device,
     *     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
     *     const VkAllocationCallbacks*                pAllocator);
     * 
     * 
Valid Usage
     * 
     * 

     * 
If {@link VkAllocationCallbacks} were provided when {@code descriptorUpdateTemplate} was created, a compatible set of callbacks must be provided here
     * 
If no {@link VkAllocationCallbacks} were provided when {@code descriptorUpdateTemplate} was created, {@code pAllocator} must be {@code NULL}
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
If {@code descriptorUpdateTemplate} is not {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, {@code descriptorUpdateTemplate} must be a valid {@code VkDescriptorUpdateTemplate} handle
     * 
If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
     * 
If {@code descriptorUpdateTemplate} is a valid handle, it must have been created, allocated, or retrieved from {@code device}
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code descriptorUpdateTemplate} must be externally synchronized
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkAllocationCallbacks}
     *
     * @param device                   the logical device that has been used to create the descriptor update template
     * @param descriptorUpdateTemplate the descriptor update template to destroy.
     * @param pAllocator               controls host memory allocation as described in the Memory Allocation chapter.
     */
    public static void vkDestroyDescriptorUpdateTemplate(VkDevice device, @NativeType("VkDescriptorUpdateTemplate") long descriptorUpdateTemplate, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator) {
        nvkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, memAddressSafe(pAllocator));
    }

    // --- [ vkUpdateDescriptorSetWithTemplate ] ---

    /**
     * Update the contents of a descriptor set object using an update template.
     * 
     * 
C Specification
     * 
     * 
Once a {@code VkDescriptorUpdateTemplate} has been created, descriptor sets can be updated by calling:
     * 
     * 

     * void vkUpdateDescriptorSetWithTemplate(
     *     VkDevice                                    device,
     *     VkDescriptorSet                             descriptorSet,
     *     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
     *     const void*                                 pData);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkUpdateDescriptorSetWithTemplateKHR(
     *     VkDevice                                    device,
     *     VkDescriptorSet                             descriptorSet,
     *     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
     *     const void*                                 pData);
     * 
     * 
Valid Usage
     * 
     * 

     * 
{@code pData} must be a valid pointer to a memory containing one or more valid instances of {@link VkDescriptorImageInfo}, {@link VkDescriptorBufferInfo}, or {@code VkBufferView} in a layout defined by {@code descriptorUpdateTemplate} when it was created with {@link #vkCreateDescriptorUpdateTemplate CreateDescriptorUpdateTemplate}
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code descriptorSet} must be a valid {@code VkDescriptorSet} handle
     * 
{@code descriptorUpdateTemplate} must be a valid {@code VkDescriptorUpdateTemplate} handle
     * 
{@code descriptorUpdateTemplate} must have been created, allocated, or retrieved from {@code device}
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code descriptorSet} must be externally synchronized
     * 
     * 
     * 

     * struct AppBufferView {
     *     VkBufferView bufferView;
     *     uint32_t     applicationRelatedInformation;
     * };
     * 
     * struct AppDataStructure
     * {
     *     VkDescriptorImageInfo  imageInfo;          // a single image info
     *     VkDescriptorBufferInfo bufferInfoArray[3]; // 3 buffer infos in an array
     *     AppBufferView          bufferView[2];      // An application defined structure containing a bufferView
     *     // ... some more application related data
     * };
     * 
     * const VkDescriptorUpdateTemplateEntry descriptorUpdateTemplateEntries[] =
     * {
     *     // binding to a single image descriptor
     *     {
     *         0,                                           // binding
     *         0,                                           // dstArrayElement
     *         1,                                           // descriptorCount
     *         VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,   // descriptorType
     *         offsetof(AppDataStructure, imageInfo),       // offset
     *         0                                            // stride is not required if descriptorCount is 1
     *     },
     * 
     *     // binding to an array of buffer descriptors
     *     {
     *         1,                                           // binding
     *         0,                                           // dstArrayElement
     *         3,                                           // descriptorCount
     *         VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,           // descriptorType
     *         offsetof(AppDataStructure, bufferInfoArray), // offset
     *         sizeof(VkDescriptorBufferInfo)               // stride, descriptor buffer infos are compact
     *     },
     * 
     *     // binding to an array of buffer views
     *     {
     *         2,                                           // binding
     *         0,                                           // dstArrayElement
     *         2,                                           // descriptorCount
     *         VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,     // descriptorType
     *         offsetof(AppDataStructure, bufferView) +
     *           offsetof(AppBufferView, bufferView),       // offset
     *         sizeof(AppBufferView)                        // stride, bufferViews do not have to be compact
     *     },
     * };
     * 
     * // create a descriptor update template for descriptor set updates
     * const VkDescriptorUpdateTemplateCreateInfo createInfo =
     * {
     *     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,  // sType
     *     NULL,                                                      // pNext
     *     0,                                                         // flags
     *     3,                                                         // descriptorUpdateEntryCount
     *     descriptorUpdateTemplateEntries,                           // pDescriptorUpdateEntries
     *     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,         // templateType
     *     myLayout,                                                  // descriptorSetLayout
     *     0,                                                         // pipelineBindPoint, ignored by given templateType
     *     0,                                                         // pipelineLayout, ignored by given templateType
     *     0,                                                         // set, ignored by given templateType
     * };
     * 
     * VkDescriptorUpdateTemplate myDescriptorUpdateTemplate;
     * myResult = vkCreateDescriptorUpdateTemplate(
     *     myDevice,
     *     &createInfo,
     *     NULL,
     *     &myDescriptorUpdateTemplate);
     * 
     * AppDataStructure appData;
     * 
     * // fill appData here or cache it in your engine
     * vkUpdateDescriptorSetWithTemplate(myDevice, myDescriptorSet, myDescriptorUpdateTemplate, &appData);
     *
     * @param device                   the logical device that updates the descriptor set.
     * @param descriptorSet            the descriptor set to update
     * @param descriptorUpdateTemplate a {@code VkDescriptorUpdateTemplate} object specifying the update mapping between {@code pData} and the descriptor set to update.
     * @param pData                    a pointer to memory containing one or more {@link VkDescriptorImageInfo}, {@link VkDescriptorBufferInfo}, or {@code VkBufferView} structures or {@code VkAccelerationStructureKHR} or {@code VkAccelerationStructureNV} handles used to write the descriptors.
     */
    public static void vkUpdateDescriptorSetWithTemplate(VkDevice device, @NativeType("VkDescriptorSet") long descriptorSet, @NativeType("VkDescriptorUpdateTemplate") long descriptorUpdateTemplate, @NativeType("void const *") long pData) {
        long __functionAddress = device.getCapabilities().vkUpdateDescriptorSetWithTemplate;
        if (CHECKS) {
            check(__functionAddress);
            check(pData);
        }
        callPJJPV(device.address(), descriptorSet, descriptorUpdateTemplate, pData, __functionAddress);
    }

    // --- [ vkGetPhysicalDeviceExternalBufferProperties ] ---

    /** Unsafe version of: {@link #vkGetPhysicalDeviceExternalBufferProperties GetPhysicalDeviceExternalBufferProperties} */
    public static void nvkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, long pExternalBufferInfo, long pExternalBufferProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceExternalBufferProperties;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPV(physicalDevice.address(), pExternalBufferInfo, pExternalBufferProperties, __functionAddress);
    }

    /**
     * Query external handle types supported by buffers.
     * 
     * 
C Specification
     * 
     * 
To query the external handle types supported by buffers, call:
     * 
     * 

     * void vkGetPhysicalDeviceExternalBufferProperties(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
     *     VkExternalBufferProperties*                 pExternalBufferProperties);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetPhysicalDeviceExternalBufferPropertiesKHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
     *     VkExternalBufferProperties*                 pExternalBufferProperties);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code pExternalBufferInfo} must be a valid pointer to a valid {@link VkPhysicalDeviceExternalBufferInfo} structure
     * 
{@code pExternalBufferProperties} must be a valid pointer to a {@link VkExternalBufferProperties} structure
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkExternalBufferProperties}, {@link VkPhysicalDeviceExternalBufferInfo}
     *
     * @param physicalDevice            the physical device from which to query the buffer capabilities.
     * @param pExternalBufferInfo       a pointer to a {@link VkPhysicalDeviceExternalBufferInfo} structure describing the parameters that would be consumed by {@link VK10#vkCreateBuffer CreateBuffer}.
     * @param pExternalBufferProperties a pointer to a {@link VkExternalBufferProperties} structure in which capabilities are returned.
     */
    public static void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, @NativeType("VkPhysicalDeviceExternalBufferInfo const *") VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo, @NativeType("VkExternalBufferProperties *") VkExternalBufferProperties pExternalBufferProperties) {
        nvkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo.address(), pExternalBufferProperties.address());
    }

    // --- [ vkGetPhysicalDeviceExternalFenceProperties ] ---

    /** Unsafe version of: {@link #vkGetPhysicalDeviceExternalFenceProperties GetPhysicalDeviceExternalFenceProperties} */
    public static void nvkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, long pExternalFenceInfo, long pExternalFenceProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceExternalFenceProperties;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPV(physicalDevice.address(), pExternalFenceInfo, pExternalFenceProperties, __functionAddress);
    }

    /**
     * Function for querying external fence handle capabilities.
     * 
     * 
C Specification
     * 
     * 
Fences may support import and export of their payload to external handles. To query the external handle types supported by fences, call:
     * 
     * 

     * void vkGetPhysicalDeviceExternalFenceProperties(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
     *     VkExternalFenceProperties*                  pExternalFenceProperties);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetPhysicalDeviceExternalFencePropertiesKHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
     *     VkExternalFenceProperties*                  pExternalFenceProperties);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code pExternalFenceInfo} must be a valid pointer to a valid {@link VkPhysicalDeviceExternalFenceInfo} structure
     * 
{@code pExternalFenceProperties} must be a valid pointer to a {@link VkExternalFenceProperties} structure
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkExternalFenceProperties}, {@link VkPhysicalDeviceExternalFenceInfo}
     *
     * @param physicalDevice           the physical device from which to query the fence capabilities.
     * @param pExternalFenceInfo       a pointer to a {@link VkPhysicalDeviceExternalFenceInfo} structure describing the parameters that would be consumed by {@link VK10#vkCreateFence CreateFence}.
     * @param pExternalFenceProperties a pointer to a {@link VkExternalFenceProperties} structure in which capabilities are returned.
     */
    public static void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, @NativeType("VkPhysicalDeviceExternalFenceInfo const *") VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo, @NativeType("VkExternalFenceProperties *") VkExternalFenceProperties pExternalFenceProperties) {
        nvkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo.address(), pExternalFenceProperties.address());
    }

    // --- [ vkGetPhysicalDeviceExternalSemaphoreProperties ] ---

    /** Unsafe version of: {@link #vkGetPhysicalDeviceExternalSemaphoreProperties GetPhysicalDeviceExternalSemaphoreProperties} */
    public static void nvkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, long pExternalSemaphoreInfo, long pExternalSemaphoreProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceExternalSemaphoreProperties;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPV(physicalDevice.address(), pExternalSemaphoreInfo, pExternalSemaphoreProperties, __functionAddress);
    }

    /**
     * Function for querying external semaphore handle capabilities.
     * 
     * 
C Specification
     * 
     * 
Semaphores may support import and export of their payload to external handles. To query the external handle types supported by semaphores, call:
     * 
     * 

     * void vkGetPhysicalDeviceExternalSemaphoreProperties(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
     *     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
     *     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code pExternalSemaphoreInfo} must be a valid pointer to a valid {@link VkPhysicalDeviceExternalSemaphoreInfo} structure
     * 
{@code pExternalSemaphoreProperties} must be a valid pointer to a {@link VkExternalSemaphoreProperties} structure
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkExternalSemaphoreProperties}, {@link VkPhysicalDeviceExternalSemaphoreInfo}
     *
     * @param physicalDevice               the physical device from which to query the semaphore capabilities.
     * @param pExternalSemaphoreInfo       a pointer to a {@link VkPhysicalDeviceExternalSemaphoreInfo} structure describing the parameters that would be consumed by {@link VK10#vkCreateSemaphore CreateSemaphore}.
     * @param pExternalSemaphoreProperties a pointer to a {@link VkExternalSemaphoreProperties} structure in which capabilities are returned.
     */
    public static void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, @NativeType("VkPhysicalDeviceExternalSemaphoreInfo const *") VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo, @NativeType("VkExternalSemaphoreProperties *") VkExternalSemaphoreProperties pExternalSemaphoreProperties) {
        nvkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo.address(), pExternalSemaphoreProperties.address());
    }

    // --- [ vkGetDescriptorSetLayoutSupport ] ---

    /** Unsafe version of: {@link #vkGetDescriptorSetLayoutSupport GetDescriptorSetLayoutSupport} */
    public static void nvkGetDescriptorSetLayoutSupport(VkDevice device, long pCreateInfo, long pSupport) {
        long __functionAddress = device.getCapabilities().vkGetDescriptorSetLayoutSupport;
        if (CHECKS) {
            check(__functionAddress);
            VkDescriptorSetLayoutCreateInfo.validate(pCreateInfo);
        }
        callPPPV(device.address(), pCreateInfo, pSupport, __functionAddress);
    }

    /**
     * Query whether a descriptor set layout can be created.
     * 
     * 
C Specification
     * 
     * 
To query information about whether a descriptor set layout can be created, call:
     * 
     * 

     * void vkGetDescriptorSetLayoutSupport(
     *     VkDevice                                    device,
     *     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
     *     VkDescriptorSetLayoutSupport*               pSupport);
     * 
     * 
or the equivalent command
     * 
     * 

     * void vkGetDescriptorSetLayoutSupportKHR(
     *     VkDevice                                    device,
     *     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
     *     VkDescriptorSetLayoutSupport*               pSupport);
     * 
     * 
Description
     * 
     * 
Some implementations have limitations on what fits in a descriptor set which are not easily expressible in terms of existing limits like {@code maxDescriptorSet}*, for example if all descriptor types share a limited space in memory but each descriptor is a different size or alignment. This command returns information about whether a descriptor set satisfies this limit. If the descriptor set layout satisfies the {@link VkPhysicalDeviceMaintenance3Properties}{@code ::maxPerSetDescriptors} limit, this command is guaranteed to return {@link VK10#VK_TRUE TRUE} in {@link VkDescriptorSetLayoutSupport}{@code ::supported}. If the descriptor set layout exceeds the {@link VkPhysicalDeviceMaintenance3Properties}{@code ::maxPerSetDescriptors} limit, whether the descriptor set layout is supported is implementation-dependent and may depend on whether the descriptor sizes and alignments cause the layout to exceed an internal limit.
     * 
     * 
This command does not consider other limits such as {@code maxPerStageDescriptor}*, and so a descriptor set layout that is supported according to this command must still satisfy the pipeline layout limits such as {@code maxPerStageDescriptor}* in order to be used in a pipeline layout.
     * 
     * 
Note
     * 
     * 
This is a {@code VkDevice} query rather than {@code VkPhysicalDevice} because the answer may depend on enabled features.
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pCreateInfo} must be a valid pointer to a valid {@link VkDescriptorSetLayoutCreateInfo} structure
     * 
{@code pSupport} must be a valid pointer to a {@link VkDescriptorSetLayoutSupport} structure
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkDescriptorSetLayoutCreateInfo}, {@link VkDescriptorSetLayoutSupport}
     *
     * @param device      the logical device that would create the descriptor set layout.
     * @param pCreateInfo a pointer to a {@link VkDescriptorSetLayoutCreateInfo} structure specifying the state of the descriptor set layout object.
     * @param pSupport    a pointer to a {@link VkDescriptorSetLayoutSupport} structure, in which information about support for the descriptor set layout object is returned.
     */
    public static void vkGetDescriptorSetLayoutSupport(VkDevice device, @NativeType("VkDescriptorSetLayoutCreateInfo const *") VkDescriptorSetLayoutCreateInfo pCreateInfo, @NativeType("VkDescriptorSetLayoutSupport *") VkDescriptorSetLayoutSupport pSupport) {
        nvkGetDescriptorSetLayoutSupport(device, pCreateInfo.address(), pSupport.address());
    }

    /** Array version of: {@link #vkEnumerateInstanceVersion EnumerateInstanceVersion} */
    @NativeType("VkResult")
    public static int vkEnumerateInstanceVersion(@NativeType("uint32_t *") int[] pApiVersion) {
        long __functionAddress = VK.getGlobalCommands().vkEnumerateInstanceVersion;
        if (CHECKS) {
            check(__functionAddress);
            check(pApiVersion, 1);
        }
        return callPI(pApiVersion, __functionAddress);
    }

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

    /** Array version of: {@link #vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups} */
    @NativeType("VkResult")
    public static int vkEnumeratePhysicalDeviceGroups(VkInstance instance, @NativeType("uint32_t *") int[] pPhysicalDeviceGroupCount, @Nullable @NativeType("VkPhysicalDeviceGroupProperties *") VkPhysicalDeviceGroupProperties.Buffer pPhysicalDeviceGroupProperties) {
        long __functionAddress = instance.getCapabilities().vkEnumeratePhysicalDeviceGroups;
        if (CHECKS) {
            check(__functionAddress);
            check(pPhysicalDeviceGroupCount, 1);
            checkSafe(pPhysicalDeviceGroupProperties, pPhysicalDeviceGroupCount[0]);
        }
        return callPPPI(instance.address(), pPhysicalDeviceGroupCount, memAddressSafe(pPhysicalDeviceGroupProperties), __functionAddress);
    }

    /** Array version of: {@link #vkGetImageSparseMemoryRequirements2 GetImageSparseMemoryRequirements2} */
    public static void vkGetImageSparseMemoryRequirements2(VkDevice device, @NativeType("VkImageSparseMemoryRequirementsInfo2 const *") VkImageSparseMemoryRequirementsInfo2 pInfo, @NativeType("uint32_t *") int[] pSparseMemoryRequirementCount, @Nullable @NativeType("VkSparseImageMemoryRequirements2 *") VkSparseImageMemoryRequirements2.Buffer pSparseMemoryRequirements) {
        long __functionAddress = device.getCapabilities().vkGetImageSparseMemoryRequirements2;
        if (CHECKS) {
            check(__functionAddress);
            check(pSparseMemoryRequirementCount, 1);
            checkSafe(pSparseMemoryRequirements, pSparseMemoryRequirementCount[0]);
        }
        callPPPPV(device.address(), pInfo.address(), pSparseMemoryRequirementCount, memAddressSafe(pSparseMemoryRequirements), __functionAddress);
    }

    /** Array version of: {@link #vkGetPhysicalDeviceQueueFamilyProperties2 GetPhysicalDeviceQueueFamilyProperties2} */
    public static void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, @NativeType("uint32_t *") int[] pQueueFamilyPropertyCount, @Nullable @NativeType("VkQueueFamilyProperties2 *") VkQueueFamilyProperties2.Buffer pQueueFamilyProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceQueueFamilyProperties2;
        if (CHECKS) {
            check(__functionAddress);
            check(pQueueFamilyPropertyCount, 1);
            checkSafe(pQueueFamilyProperties, pQueueFamilyPropertyCount[0]);
        }
        callPPPV(physicalDevice.address(), pQueueFamilyPropertyCount, memAddressSafe(pQueueFamilyProperties), __functionAddress);
    }

    /** Array version of: {@link #vkGetPhysicalDeviceSparseImageFormatProperties2 GetPhysicalDeviceSparseImageFormatProperties2} */
    public static void vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, @NativeType("VkPhysicalDeviceSparseImageFormatInfo2 const *") VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo, @NativeType("uint32_t *") int[] pPropertyCount, @Nullable @NativeType("VkSparseImageFormatProperties2 *") VkSparseImageFormatProperties2.Buffer pProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceSparseImageFormatProperties2;
        if (CHECKS) {
            check(__functionAddress);
            check(pPropertyCount, 1);
            checkSafe(pProperties, pPropertyCount[0]);
        }
        callPPPPV(physicalDevice.address(), pFormatInfo.address(), pPropertyCount, memAddressSafe(pProperties), __functionAddress);
    }

    /** Array version of: {@link #vkCreateSamplerYcbcrConversion CreateSamplerYcbcrConversion} */
    @NativeType("VkResult")
    public static int vkCreateSamplerYcbcrConversion(VkDevice device, @NativeType("VkSamplerYcbcrConversionCreateInfo const *") VkSamplerYcbcrConversionCreateInfo pCreateInfo, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator, @NativeType("VkSamplerYcbcrConversion *") long[] pYcbcrConversion) {
        long __functionAddress = device.getCapabilities().vkCreateSamplerYcbcrConversion;
        if (CHECKS) {
            check(__functionAddress);
            check(pYcbcrConversion, 1);
            if (pAllocator != null) { VkAllocationCallbacks.validate(pAllocator.address()); }
        }
        return callPPPPI(device.address(), pCreateInfo.address(), memAddressSafe(pAllocator), pYcbcrConversion, __functionAddress);
    }

    /** Array version of: {@link #vkCreateDescriptorUpdateTemplate CreateDescriptorUpdateTemplate} */
    @NativeType("VkResult")
    public static int vkCreateDescriptorUpdateTemplate(VkDevice device, @NativeType("VkDescriptorUpdateTemplateCreateInfo const *") VkDescriptorUpdateTemplateCreateInfo pCreateInfo, @Nullable @NativeType("VkAllocationCallbacks const *") VkAllocationCallbacks pAllocator, @NativeType("VkDescriptorUpdateTemplate *") long[] pDescriptorUpdateTemplate) {
        long __functionAddress = device.getCapabilities().vkCreateDescriptorUpdateTemplate;
        if (CHECKS) {
            check(__functionAddress);
            check(pDescriptorUpdateTemplate, 1);
            VkDescriptorUpdateTemplateCreateInfo.validate(pCreateInfo.address());
            if (pAllocator != null) { VkAllocationCallbacks.validate(pAllocator.address()); }
        }
        return callPPPPI(device.address(), pCreateInfo.address(), memAddressSafe(pAllocator), pDescriptorUpdateTemplate, __functionAddress);
    }

}