Class VK10



  • public class VK10
    extends java.lang.Object
    The core Vulkan 1.0 functionality.
    • Field Detail

      • VK_API_VERSION_1_0

        public static final int VK_API_VERSION_1_0
        The Vulkan version number is used in several places in the API. In each such use, the API major version number, minor version number, and patch version number are packed into a 32-bit integer as follows:
        • The major version number is a 10-bit integer packed into bits 31-22.
        • The minor version number is a 10-bit integer packed into bits 21-12.
        • The patch version number is a 12-bit integer packed into bits 11-0.

        Differences in any of the Vulkan version numbers indicates a change to the API in some way, with each part of the version number indicating a different scope of changes.

        A difference in patch version numbers indicates that some usually small aspect of the specification or header has been modified, typically to fix a bug, and may have an impact on the behavior of existing functionality. Differences in this version number should not affect either full compatibility or backwards compatibility between two versions, or add additional interfaces to the API.

        A difference in minor version numbers indicates that some amount of new functionality has been added. This will usually include new interfaces in the header, and may also include behavior changes and bug fixes. Functionality may be deprecated in a minor revision, but will not be removed. When a new minor version is introduced, the patch version is reset to 0, and each minor revision maintains its own set of patch versions. Differences in this version should not affect backwards compatibility, but will affect full compatibility.

        A difference in major version numbers indicates a large set of changes to the API, potentially including new functionality and header interfaces, behavioral changes, removal of deprecated features, modification or outright replacement of any feature, and is thus very likely to break any and all compatibility. Differences in this version will typically require significant modification to an application in order for it to function.

      • VK_NULL_HANDLE

        public static final long VK_NULL_HANDLE
        The reserved handle VK_NULL_HANDLE can be passed in place of valid object handles when explicitly called out in the specification. Any command that creates an object successfully must not return VK_NULL_HANDLE. It is valid to pass VK_NULL_HANDLE to any vkDestroy* or vkFree* command, which will silently ignore these values.
        See Also:
        Constant Field Values
      • VK_MAX_PHYSICAL_DEVICE_NAME_SIZE

        public static final int VK_MAX_PHYSICAL_DEVICE_NAME_SIZE
        Struct member limits.
        See Also:
        Constant Field Values
      • VK_UUID_SIZE

        public static final int VK_UUID_SIZE
        Struct member limits.
        See Also:
        Constant Field Values
      • VK_MAX_MEMORY_TYPES

        public static final int VK_MAX_MEMORY_TYPES
        Struct member limits.
        See Also:
        Constant Field Values
      • VK_MAX_MEMORY_HEAPS

        public static final int VK_MAX_MEMORY_HEAPS
        Struct member limits.
        See Also:
        Constant Field Values
      • VK_MAX_EXTENSION_NAME_SIZE

        public static final int VK_MAX_EXTENSION_NAME_SIZE
        Struct member limits.
        See Also:
        Constant Field Values
      • VK_MAX_DESCRIPTION_SIZE

        public static final int VK_MAX_DESCRIPTION_SIZE
        Struct member limits.
        See Also:
        Constant Field Values
      • VK_REMAINING_MIP_LEVELS

        public static final int VK_REMAINING_MIP_LEVELS
        Special values.
        See Also:
        Constant Field Values
      • VK_REMAINING_ARRAY_LAYERS

        public static final int VK_REMAINING_ARRAY_LAYERS
        Special values.
        See Also:
        Constant Field Values
      • VK_ATTACHMENT_UNUSED

        public static final int VK_ATTACHMENT_UNUSED
        Special values.
        See Also:
        Constant Field Values
      • VK_QUEUE_FAMILY_IGNORED

        public static final int VK_QUEUE_FAMILY_IGNORED
        Special values.
        See Also:
        Constant Field Values
      • VK_SUBPASS_EXTERNAL

        public static final int VK_SUBPASS_EXTERNAL
        Special values.
        See Also:
        Constant Field Values
      • VK_WHOLE_SIZE

        public static final long VK_WHOLE_SIZE
        Special size value.
        See Also:
        Constant Field Values
      • VK_PIPELINE_CACHE_HEADER_VERSION_ONE

        public static final int VK_PIPELINE_CACHE_HEADER_VERSION_ONE
        VkPipelineCacheHeaderVersion
        See Also:
        Constant Field Values
      • VK_SUCCESS

        public static final int VK_SUCCESS
        Command successfully completed.
        See Also:
        Constant Field Values
      • VK_NOT_READY

        public static final int VK_NOT_READY
        A fence or query has not yet completed.
        See Also:
        Constant Field Values
      • VK_TIMEOUT

        public static final int VK_TIMEOUT
        A wait operation has not completed in the specified time.
        See Also:
        Constant Field Values
      • VK_EVENT_SET

        public static final int VK_EVENT_SET
        An event is signaled.
        See Also:
        Constant Field Values
      • VK_EVENT_RESET

        public static final int VK_EVENT_RESET
        An event is unsignaled.
        See Also:
        Constant Field Values
      • VK_INCOMPLETE

        public static final int VK_INCOMPLETE
        A return array was too small for the result.
        See Also:
        Constant Field Values
      • VK_ERROR_OUT_OF_HOST_MEMORY

        public static final int VK_ERROR_OUT_OF_HOST_MEMORY
        A host memory allocation has failed.
        See Also:
        Constant Field Values
      • VK_ERROR_OUT_OF_DEVICE_MEMORY

        public static final int VK_ERROR_OUT_OF_DEVICE_MEMORY
        A device memory allocation has failed.
        See Also:
        Constant Field Values
      • VK_ERROR_INITIALIZATION_FAILED

        public static final int VK_ERROR_INITIALIZATION_FAILED
        Initialization of an object could not be completed for implementation-specific reasons.
        See Also:
        Constant Field Values
      • VK_ERROR_DEVICE_LOST

        public static final int VK_ERROR_DEVICE_LOST
        The logical or physical device has been lost.
        See Also:
        Constant Field Values
      • VK_ERROR_MEMORY_MAP_FAILED

        public static final int VK_ERROR_MEMORY_MAP_FAILED
        Mapping of a memory object has failed.
        See Also:
        Constant Field Values
      • VK_ERROR_LAYER_NOT_PRESENT

        public static final int VK_ERROR_LAYER_NOT_PRESENT
        A requested layer is not present or could not be loaded.
        See Also:
        Constant Field Values
      • VK_ERROR_EXTENSION_NOT_PRESENT

        public static final int VK_ERROR_EXTENSION_NOT_PRESENT
        A requested extension is not supported.
        See Also:
        Constant Field Values
      • VK_ERROR_FEATURE_NOT_PRESENT

        public static final int VK_ERROR_FEATURE_NOT_PRESENT
        A requested feature is not supported.
        See Also:
        Constant Field Values
      • VK_ERROR_INCOMPATIBLE_DRIVER

        public static final int VK_ERROR_INCOMPATIBLE_DRIVER
        The requested version of Vulkan is not supported by the driver or is otherwise incompatible for implementation-specific reasons.
        See Also:
        Constant Field Values
      • VK_ERROR_TOO_MANY_OBJECTS

        public static final int VK_ERROR_TOO_MANY_OBJECTS
        Too many objects of the type have already been created.
        See Also:
        Constant Field Values
      • VK_ERROR_FORMAT_NOT_SUPPORTED

        public static final int VK_ERROR_FORMAT_NOT_SUPPORTED
        A requested format is not supported on this device.
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_APPLICATION_INFO

        public static final int VK_STRUCTURE_TYPE_APPLICATION_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_SUBMIT_INFO

        public static final int VK_STRUCTURE_TYPE_SUBMIT_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO

        public static final int VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE

        public static final int VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_BIND_SPARSE_INFO

        public static final int VK_STRUCTURE_TYPE_BIND_SPARSE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_FENCE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_EVENT_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO

        public static final int VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET

        public static final int VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET

        public static final int VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO

        public static final int VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO

        public static final int VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO

        public static final int VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO

        public static final int VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER

        public static final int VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER

        public static final int VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_MEMORY_BARRIER

        public static final int VK_STRUCTURE_TYPE_MEMORY_BARRIER
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO

        public static final int VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
        VkStructureType
        See Also:
        Constant Field Values
      • VK_SYSTEM_ALLOCATION_SCOPE_COMMAND

        public static final int VK_SYSTEM_ALLOCATION_SCOPE_COMMAND
        The allocation is scoped to the duration of the Vulkan command.
        See Also:
        Constant Field Values
      • VK_SYSTEM_ALLOCATION_SCOPE_OBJECT

        public static final int VK_SYSTEM_ALLOCATION_SCOPE_OBJECT
        The allocation is scoped to the lifetime of the Vulkan object that is being created or used.
        See Also:
        Constant Field Values
      • VK_SYSTEM_ALLOCATION_SCOPE_CACHE

        public static final int VK_SYSTEM_ALLOCATION_SCOPE_CACHE
        The allocation is scoped to the lifetime of a VkPipelineCache object.
        See Also:
        Constant Field Values
      • VK_SYSTEM_ALLOCATION_SCOPE_DEVICE

        public static final int VK_SYSTEM_ALLOCATION_SCOPE_DEVICE
        The allocation is scoped to the lifetime of the Vulkan device.
        See Also:
        Constant Field Values
      • VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE

        public static final int VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
        The allocation is scoped to the lifetime of the Vulkan instance.
        See Also:
        Constant Field Values
      • VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE

        public static final int VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
        The allocation is intended for execution by the host.
        See Also:
        Constant Field Values
      • VK_FORMAT_UNDEFINED

        public static final int VK_FORMAT_UNDEFINED
        The format is not specified.
        See Also:
        Constant Field Values
      • VK_FORMAT_R4G4_UNORM_PACK8

        public static final int VK_FORMAT_R4G4_UNORM_PACK8
        A two-component, 8-bit packed unsigned normalized format that has a 4-bit R component in bits 4..7, and a 4-bit G component in bits 0..3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R4G4B4A4_UNORM_PACK16

        public static final int VK_FORMAT_R4G4B4A4_UNORM_PACK16
        A four-component, 16-bit packed unsigned normalized format that has a 4-bit R component in bits 12..15, a 4-bit G component in bits 8..11, a 4-bit B component in bits 4..7, and a 4-bit A component in bits 0..3.
        See Also:
        Constant Field Values
      • VK_FORMAT_B4G4R4A4_UNORM_PACK16

        public static final int VK_FORMAT_B4G4R4A4_UNORM_PACK16
        A four-component, 16-bit packed unsigned normalized format that has a 4-bit B component in bits 12..15, a 4-bit G component in bits 8..11, a 4-bit R component in bits 4..7, and a 4-bit A component in bits 0..3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R5G6B5_UNORM_PACK16

        public static final int VK_FORMAT_R5G6B5_UNORM_PACK16
        A three-component, 16-bit packed unsigned normalized format that has a 5-bit R component in bits 11..15, a 6-bit G component in bits 5..10, and a 5-bit B component in bits 0..4.
        See Also:
        Constant Field Values
      • VK_FORMAT_B5G6R5_UNORM_PACK16

        public static final int VK_FORMAT_B5G6R5_UNORM_PACK16
        A three-component, 16-bit packed unsigned normalized format that has a 5-bit B component in bits 11..15, a 6-bit G component in bits 5..10, and a 5-bit R component in bits 0..4.
        See Also:
        Constant Field Values
      • VK_FORMAT_R5G5B5A1_UNORM_PACK16

        public static final int VK_FORMAT_R5G5B5A1_UNORM_PACK16
        A four-component, 16-bit packed unsigned normalized format that has a 5-bit R component in bits 11..15, a 5-bit G component in bits 6..10, a 5-bit B component in bits 1..5, and a 1-bit A component in bit 0.
        See Also:
        Constant Field Values
      • VK_FORMAT_B5G5R5A1_UNORM_PACK16

        public static final int VK_FORMAT_B5G5R5A1_UNORM_PACK16
        A four-component, 16-bit packed unsigned normalized format that has a 5-bit B component in bits 11..15, a 5-bit G component in bits 6..10, a 5-bit R component in bits 1..5, and a 1-bit A component in bit 0.
        See Also:
        Constant Field Values
      • VK_FORMAT_A1R5G5B5_UNORM_PACK16

        public static final int VK_FORMAT_A1R5G5B5_UNORM_PACK16
        A four-component, 16-bit packed unsigned normalized format that has a 1-bit A component in bit 15, a 5-bit R component in bits 10..14, a 5-bit G component in bits 5..9, and a 5-bit B component in bits 0..4.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8_UNORM

        public static final int VK_FORMAT_R8_UNORM
        A one-component, 8-bit unsigned normalized format that has a single 8-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8_SNORM

        public static final int VK_FORMAT_R8_SNORM
        A one-component, 8-bit signed normalized format that has a single 8-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8_USCALED

        public static final int VK_FORMAT_R8_USCALED
        A one-component, 8-bit unsigned scaled integer format that has a single 8-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8_SSCALED

        public static final int VK_FORMAT_R8_SSCALED
        A one-component, 8-bit signed scaled integer format that has a single 8-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8_UINT

        public static final int VK_FORMAT_R8_UINT
        A one-component, 8-bit unsigned integer format that has a single 8-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8_SINT

        public static final int VK_FORMAT_R8_SINT
        A one-component, 8-bit signed integer format that has a single 8-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8_SRGB

        public static final int VK_FORMAT_R8_SRGB
        A one-component, 8-bit unsigned normalized format that has a single 8-bit R component stored with sRGB nonlinear encoding.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8_UNORM

        public static final int VK_FORMAT_R8G8_UNORM
        A two-component, 16-bit unsigned normalized format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8_SNORM

        public static final int VK_FORMAT_R8G8_SNORM
        A two-component, 16-bit signed normalized format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8_USCALED

        public static final int VK_FORMAT_R8G8_USCALED
        A two-component, 16-bit unsigned scaled integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8_SSCALED

        public static final int VK_FORMAT_R8G8_SSCALED
        A two-component, 16-bit signed scaled integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8_UINT

        public static final int VK_FORMAT_R8G8_UINT
        A two-component, 16-bit unsigned integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8_SINT

        public static final int VK_FORMAT_R8G8_SINT
        A two-component, 16-bit signed integer format that has an 8-bit R component in byte 0, and an 8-bit G component in byte 1.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8_SRGB

        public static final int VK_FORMAT_R8G8_SRGB
        A two-component, 16-bit unsigned normalized format that has an 8-bit R component stored with sRGB nonlinear encoding in byte 0, and an 8-bit G component stored with sRGB nonlinear encoding in byte 1.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8_UNORM

        public static final int VK_FORMAT_R8G8B8_UNORM
        A three-component, 24-bit unsigned normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8_SNORM

        public static final int VK_FORMAT_R8G8B8_SNORM
        A three-component, 24-bit signed normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8_USCALED

        public static final int VK_FORMAT_R8G8B8_USCALED
        A three-component, 24-bit unsigned scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8_SSCALED

        public static final int VK_FORMAT_R8G8B8_SSCALED
        A three-component, 24-bit signed scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8_UINT

        public static final int VK_FORMAT_R8G8B8_UINT
        A three-component, 24-bit unsigned integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8_SINT

        public static final int VK_FORMAT_R8G8B8_SINT
        A three-component, 24-bit signed integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, and an 8-bit B component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8_SRGB

        public static final int VK_FORMAT_R8G8B8_SRGB
        A three-component, 24-bit unsigned normalized format that has an 8-bit R component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, and an 8-bit B component stored with sRGB nonlinear encoding in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8_UNORM

        public static final int VK_FORMAT_B8G8R8_UNORM
        A three-component, 24-bit unsigned normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8_SNORM

        public static final int VK_FORMAT_B8G8R8_SNORM
        A three-component, 24-bit signed normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8_USCALED

        public static final int VK_FORMAT_B8G8R8_USCALED
        A three-component, 24-bit unsigned scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8_SSCALED

        public static final int VK_FORMAT_B8G8R8_SSCALED
        A three-component, 24-bit signed scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8_UINT

        public static final int VK_FORMAT_B8G8R8_UINT
        A three-component, 24-bit unsigned integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8_SINT

        public static final int VK_FORMAT_B8G8R8_SINT
        A three-component, 24-bit signed integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, and an 8-bit R component in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8_SRGB

        public static final int VK_FORMAT_B8G8R8_SRGB
        A three-component, 24-bit unsigned normalized format that has an 8-bit B component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, and an 8-bit R component stored with sRGB nonlinear encoding in byte 2.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8A8_UNORM

        public static final int VK_FORMAT_R8G8B8A8_UNORM
        A four-component, 32-bit unsigned normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8A8_SNORM

        public static final int VK_FORMAT_R8G8B8A8_SNORM
        A four-component, 32-bit signed normalized format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8A8_USCALED

        public static final int VK_FORMAT_R8G8B8A8_USCALED
        A four-component, 32-bit unsigned scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8A8_SSCALED

        public static final int VK_FORMAT_R8G8B8A8_SSCALED
        A four-component, 32-bit signed scaled format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8A8_UINT

        public static final int VK_FORMAT_R8G8B8A8_UINT
        A four-component, 32-bit unsigned integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8A8_SINT

        public static final int VK_FORMAT_R8G8B8A8_SINT
        A four-component, 32-bit signed integer format that has an 8-bit R component in byte 0, an 8-bit G component in byte 1, an 8-bit B component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R8G8B8A8_SRGB

        public static final int VK_FORMAT_R8G8B8A8_SRGB
        A four-component, 32-bit unsigned normalized format that has an 8-bit R component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, an 8-bit B component stored with sRGB nonlinear encoding in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8A8_UNORM

        public static final int VK_FORMAT_B8G8R8A8_UNORM
        A four-component, 32-bit unsigned normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8A8_SNORM

        public static final int VK_FORMAT_B8G8R8A8_SNORM
        A four-component, 32-bit signed normalized format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8A8_USCALED

        public static final int VK_FORMAT_B8G8R8A8_USCALED
        A four-component, 32-bit unsigned scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8A8_SSCALED

        public static final int VK_FORMAT_B8G8R8A8_SSCALED
        A four-component, 32-bit signed scaled format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8A8_UINT

        public static final int VK_FORMAT_B8G8R8A8_UINT
        A four-component, 32-bit unsigned integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8A8_SINT

        public static final int VK_FORMAT_B8G8R8A8_SINT
        A four-component, 32-bit signed integer format that has an 8-bit B component in byte 0, an 8-bit G component in byte 1, an 8-bit R component in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_B8G8R8A8_SRGB

        public static final int VK_FORMAT_B8G8R8A8_SRGB
        A four-component, 32-bit unsigned normalized format that has an 8-bit B component stored with sRGB nonlinear encoding in byte 0, an 8-bit G component stored with sRGB nonlinear encoding in byte 1, an 8-bit R component stored with sRGB nonlinear encoding in byte 2, and an 8-bit A component in byte 3.
        See Also:
        Constant Field Values
      • VK_FORMAT_A8B8G8R8_UNORM_PACK32

        public static final int VK_FORMAT_A8B8G8R8_UNORM_PACK32
        A four-component, 32-bit packed unsigned normalized format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_A8B8G8R8_SNORM_PACK32

        public static final int VK_FORMAT_A8B8G8R8_SNORM_PACK32
        A four-component, 32-bit packed signed normalized format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_A8B8G8R8_USCALED_PACK32

        public static final int VK_FORMAT_A8B8G8R8_USCALED_PACK32
        A four-component, 32-bit packed unsigned scaled integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_A8B8G8R8_SSCALED_PACK32

        public static final int VK_FORMAT_A8B8G8R8_SSCALED_PACK32
        A four-component, 32-bit packed signed scaled integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_A8B8G8R8_UINT_PACK32

        public static final int VK_FORMAT_A8B8G8R8_UINT_PACK32
        A four-component, 32-bit packed unsigned integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_A8B8G8R8_SINT_PACK32

        public static final int VK_FORMAT_A8B8G8R8_SINT_PACK32
        A four-component, 32-bit packed signed integer format that has an 8-bit A component in bits 24..31, an 8-bit B component in bits 16..23, an 8-bit G component in bits 8..15, and an 8-bit R component in bits 0..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_A8B8G8R8_SRGB_PACK32

        public static final int VK_FORMAT_A8B8G8R8_SRGB_PACK32
        A four-component, 32-bit packed unsigned normalized format that has an 8-bit A component in bits 24..31, an 8-bit B component stored with sRGB nonlinear encoding in bits 16..23, an 8-bit G component stored with sRGB nonlinear encoding in bits 8..15, and an 8-bit R component stored with sRGB nonlinear encoding in bits 0..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2R10G10B10_UNORM_PACK32

        public static final int VK_FORMAT_A2R10G10B10_UNORM_PACK32
        A four-component, 32-bit packed unsigned normalized format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2R10G10B10_SNORM_PACK32

        public static final int VK_FORMAT_A2R10G10B10_SNORM_PACK32
        A four-component, 32-bit packed signed normalized format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2R10G10B10_USCALED_PACK32

        public static final int VK_FORMAT_A2R10G10B10_USCALED_PACK32
        A four-component, 32-bit packed unsigned scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2R10G10B10_SSCALED_PACK32

        public static final int VK_FORMAT_A2R10G10B10_SSCALED_PACK32
        A four-component, 32-bit packed signed scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2R10G10B10_UINT_PACK32

        public static final int VK_FORMAT_A2R10G10B10_UINT_PACK32
        A four-component, 32-bit packed unsigned integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2R10G10B10_SINT_PACK32

        public static final int VK_FORMAT_A2R10G10B10_SINT_PACK32
        A four-component, 32-bit packed signed integer format that has a 2-bit A component in bits 30..31, a 10-bit R component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit B component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2B10G10R10_UNORM_PACK32

        public static final int VK_FORMAT_A2B10G10R10_UNORM_PACK32
        A four-component, 32-bit packed unsigned normalized format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2B10G10R10_SNORM_PACK32

        public static final int VK_FORMAT_A2B10G10R10_SNORM_PACK32
        A four-component, 32-bit packed signed normalized format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2B10G10R10_USCALED_PACK32

        public static final int VK_FORMAT_A2B10G10R10_USCALED_PACK32
        A four-component, 32-bit packed unsigned scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2B10G10R10_SSCALED_PACK32

        public static final int VK_FORMAT_A2B10G10R10_SSCALED_PACK32
        A four-component, 32-bit packed signed scaled integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2B10G10R10_UINT_PACK32

        public static final int VK_FORMAT_A2B10G10R10_UINT_PACK32
        A four-component, 32-bit packed unsigned integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_A2B10G10R10_SINT_PACK32

        public static final int VK_FORMAT_A2B10G10R10_SINT_PACK32
        A four-component, 32-bit packed signed integer format that has a 2-bit A component in bits 30..31, a 10-bit B component in bits 20..29, a 10-bit G component in bits 10..19, and a 10-bit R component in bits 0..9.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16_UNORM

        public static final int VK_FORMAT_R16_UNORM
        A one-component, 16-bit unsigned normalized format that has a single 16-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16_SNORM

        public static final int VK_FORMAT_R16_SNORM
        A one-component, 16-bit signed normalized format that has a single 16-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16_USCALED

        public static final int VK_FORMAT_R16_USCALED
        A one-component, 16-bit unsigned scaled integer format that has a single 16-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16_SSCALED

        public static final int VK_FORMAT_R16_SSCALED
        A one-component, 16-bit signed scaled integer format that has a single 16-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16_UINT

        public static final int VK_FORMAT_R16_UINT
        A one-component, 16-bit unsigned integer format that has a single 16-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16_SINT

        public static final int VK_FORMAT_R16_SINT
        A one-component, 16-bit signed integer format that has a single 16-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16_SFLOAT

        public static final int VK_FORMAT_R16_SFLOAT
        A one-component, 16-bit signed floating-point format that has a single 16-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16_UNORM

        public static final int VK_FORMAT_R16G16_UNORM
        A two-component, 32-bit unsigned normalized format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16_SNORM

        public static final int VK_FORMAT_R16G16_SNORM
        A two-component, 32-bit signed normalized format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16_USCALED

        public static final int VK_FORMAT_R16G16_USCALED
        A two-component, 32-bit unsigned scaled integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16_SSCALED

        public static final int VK_FORMAT_R16G16_SSCALED
        A two-component, 32-bit signed scaled integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16_UINT

        public static final int VK_FORMAT_R16G16_UINT
        A two-component, 32-bit unsigned integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16_SINT

        public static final int VK_FORMAT_R16G16_SINT
        A two-component, 32-bit signed integer format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16_SFLOAT

        public static final int VK_FORMAT_R16G16_SFLOAT
        A two-component, 32-bit signed floating-point format that has a 16-bit R component in bytes 0..1, and a 16-bit G component in bytes 2..3.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16_UNORM

        public static final int VK_FORMAT_R16G16B16_UNORM
        A three-component, 48-bit unsigned normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16_SNORM

        public static final int VK_FORMAT_R16G16B16_SNORM
        A three-component, 48-bit signed normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16_USCALED

        public static final int VK_FORMAT_R16G16B16_USCALED
        A three-component, 48-bit unsigned scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16_SSCALED

        public static final int VK_FORMAT_R16G16B16_SSCALED
        A three-component, 48-bit signed scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16_UINT

        public static final int VK_FORMAT_R16G16B16_UINT
        A three-component, 48-bit unsigned integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16_SINT

        public static final int VK_FORMAT_R16G16B16_SINT
        A three-component, 48-bit signed integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16_SFLOAT

        public static final int VK_FORMAT_R16G16B16_SFLOAT
        A three-component, 48-bit signed floating-point format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, and a 16-bit B component in bytes 4..5.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16A16_UNORM

        public static final int VK_FORMAT_R16G16B16A16_UNORM
        A four-component, 64-bit unsigned normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16A16_SNORM

        public static final int VK_FORMAT_R16G16B16A16_SNORM
        A four-component, 64-bit signed normalized format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16A16_USCALED

        public static final int VK_FORMAT_R16G16B16A16_USCALED
        A four-component, 64-bit unsigned scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16A16_SSCALED

        public static final int VK_FORMAT_R16G16B16A16_SSCALED
        A four-component, 64-bit signed scaled integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16A16_UINT

        public static final int VK_FORMAT_R16G16B16A16_UINT
        A four-component, 64-bit unsigned integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16A16_SINT

        public static final int VK_FORMAT_R16G16B16A16_SINT
        A four-component, 64-bit signed integer format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_R16G16B16A16_SFLOAT

        public static final int VK_FORMAT_R16G16B16A16_SFLOAT
        A four-component, 64-bit signed floating-point format that has a 16-bit R component in bytes 0..1, a 16-bit G component in bytes 2..3, a 16-bit B component in bytes 4..5, and a 16-bit A component in bytes 6..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32_UINT

        public static final int VK_FORMAT_R32_UINT
        A one-component, 32-bit unsigned integer format that has a single 32-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32_SINT

        public static final int VK_FORMAT_R32_SINT
        A one-component, 32-bit signed integer format that has a single 32-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32_SFLOAT

        public static final int VK_FORMAT_R32_SFLOAT
        A one-component, 32-bit signed floating-point format that has a single 32-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32G32_UINT

        public static final int VK_FORMAT_R32G32_UINT
        A two-component, 64-bit unsigned integer format that has a 32-bit R component in bytes 0..3, and a 32-bit G component in bytes 4..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32G32_SINT

        public static final int VK_FORMAT_R32G32_SINT
        A two-component, 64-bit signed integer format that has a 32-bit R component in bytes 0..3, and a 32-bit G component in bytes 4..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32G32_SFLOAT

        public static final int VK_FORMAT_R32G32_SFLOAT
        A two-component, 64-bit signed floating-point format that has a 32-bit R component in bytes 0..3, and a 32-bit G component in bytes 4..7.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32G32B32_UINT

        public static final int VK_FORMAT_R32G32B32_UINT
        A three-component, 96-bit unsigned integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, and a 32-bit B component in bytes 8..11.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32G32B32_SINT

        public static final int VK_FORMAT_R32G32B32_SINT
        A three-component, 96-bit signed integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, and a 32-bit B component in bytes 8..11.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32G32B32_SFLOAT

        public static final int VK_FORMAT_R32G32B32_SFLOAT
        A three-component, 96-bit signed floating-point format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, and a 32-bit B component in bytes 8..11.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32G32B32A32_UINT

        public static final int VK_FORMAT_R32G32B32A32_UINT
        A four-component, 128-bit unsigned integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit B component in bytes 8..11, and a 32-bit A component in bytes 12..15.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32G32B32A32_SINT

        public static final int VK_FORMAT_R32G32B32A32_SINT
        A four-component, 128-bit signed integer format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit B component in bytes 8..11, and a 32-bit A component in bytes 12..15.
        See Also:
        Constant Field Values
      • VK_FORMAT_R32G32B32A32_SFLOAT

        public static final int VK_FORMAT_R32G32B32A32_SFLOAT
        A four-component, 128-bit signed floating-point format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, a 32-bit B component in bytes 8..11, and a 32-bit A component in bytes 12..15.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64_UINT

        public static final int VK_FORMAT_R64_UINT
        A one-component, 64-bit unsigned integer format that has a single 64-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64_SINT

        public static final int VK_FORMAT_R64_SINT
        A one-component, 64-bit signed integer format that has a single 64-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64_SFLOAT

        public static final int VK_FORMAT_R64_SFLOAT
        A one-component, 64-bit signed floating-point format that has a single 64-bit R component.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64G64_UINT

        public static final int VK_FORMAT_R64G64_UINT
        A two-component, 128-bit unsigned integer format that has a 64-bit R component in bytes 0..7, and a 64-bit G component in bytes 8..15.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64G64_SINT

        public static final int VK_FORMAT_R64G64_SINT
        A two-component, 128-bit signed integer format that has a 64-bit R component in bytes 0..7, and a 64-bit G component in bytes 8..15.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64G64_SFLOAT

        public static final int VK_FORMAT_R64G64_SFLOAT
        A two-component, 128-bit signed floating-point format that has a 64-bit R component in bytes 0..7, and a 64-bit G component in bytes 8..15.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64G64B64_UINT

        public static final int VK_FORMAT_R64G64B64_UINT
        A three-component, 192-bit unsigned integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, and a 64-bit B component in bytes 16..23.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64G64B64_SINT

        public static final int VK_FORMAT_R64G64B64_SINT
        A three-component, 192-bit signed integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, and a 64-bit B component in bytes 16..23.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64G64B64_SFLOAT

        public static final int VK_FORMAT_R64G64B64_SFLOAT
        A three-component, 192-bit signed floating-point format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, and a 64-bit B component in bytes 16..23.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64G64B64A64_UINT

        public static final int VK_FORMAT_R64G64B64A64_UINT
        A four-component, 256-bit unsigned integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit B component in bytes 16..23, and a 64-bit A component in bytes 24..31.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64G64B64A64_SINT

        public static final int VK_FORMAT_R64G64B64A64_SINT
        A four-component, 256-bit signed integer format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit B component in bytes 16..23, and a 64-bit A component in bytes 24..31.
        See Also:
        Constant Field Values
      • VK_FORMAT_R64G64B64A64_SFLOAT

        public static final int VK_FORMAT_R64G64B64A64_SFLOAT
        A four-component, 256-bit signed floating-point format that has a 64-bit R component in bytes 0..7, a 64-bit G component in bytes 8..15, a 64-bit B component in bytes 16..23, and a 64-bit A component in bytes 24..31.
        See Also:
        Constant Field Values
      • VK_FORMAT_B10G11R11_UFLOAT_PACK32

        public static final int VK_FORMAT_B10G11R11_UFLOAT_PACK32
        A three-component, 32-bit packed unsigned floating-point format that has a 10-bit B component in bits 22..31, an 11-bit G component in bits 11..21, an 11-bit R component in bits 0..10.
        See Also:
        Constant Field Values
      • VK_FORMAT_E5B9G9R9_UFLOAT_PACK32

        public static final int VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
        A three-component, 32-bit packed unsigned floating-point format that has a 5-bit shared exponent in bits 27..31, a 9-bit B component mantissa in bits 18..26, a 9-bit G component mantissa in bits 9..17, and a 9-bit R component mantissa in bits 0..8.
        See Also:
        Constant Field Values
      • VK_FORMAT_D16_UNORM

        public static final int VK_FORMAT_D16_UNORM
        A one-component, 16-bit unsigned normalized format that has a single 16-bit depth component.
        See Also:
        Constant Field Values
      • VK_FORMAT_X8_D24_UNORM_PACK32

        public static final int VK_FORMAT_X8_D24_UNORM_PACK32
        A two-component, 32-bit format that has 24 unsigned normalized bits in the depth component and, optionally:, 8 bits that are unused.
        See Also:
        Constant Field Values
      • VK_FORMAT_D32_SFLOAT

        public static final int VK_FORMAT_D32_SFLOAT
        A one-component, 32-bit signed floating-point format that has 32-bits in the depth component.
        See Also:
        Constant Field Values
      • VK_FORMAT_S8_UINT

        public static final int VK_FORMAT_S8_UINT
        A one-component, 8-bit unsigned integer format that has 8-bits in the stencil component.
        See Also:
        Constant Field Values
      • VK_FORMAT_D16_UNORM_S8_UINT

        public static final int VK_FORMAT_D16_UNORM_S8_UINT
        A two-component, 24-bit format that has 16 unsigned normalized bits in the depth component and 8 unsigned integer bits in the stencil component.
        See Also:
        Constant Field Values
      • VK_FORMAT_D24_UNORM_S8_UINT

        public static final int VK_FORMAT_D24_UNORM_S8_UINT
        A two-component, 32-bit packed format that has 8 unsigned integer bits in the stencil component, and 24 unsigned normalized bits in the depth component.
        See Also:
        Constant Field Values
      • VK_FORMAT_D32_SFLOAT_S8_UINT

        public static final int VK_FORMAT_D32_SFLOAT_S8_UINT
        A two-component format that has 32 signed float bits in the depth component and 8 unsigned integer bits in the stencil component. There are optionally: 24-bits that are unused.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC1_RGB_UNORM_BLOCK

        public static final int VK_FORMAT_BC1_RGB_UNORM_BLOCK
        A three-component, block compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized RGB image data. This format has no alpha and is considered opaque.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC1_RGB_SRGB_BLOCK

        public static final int VK_FORMAT_BC1_RGB_SRGB_BLOCK
        A three-component, block compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized RGB image data with sRGB nonlinear encoding. This format has no alpha and is considered opaque.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC1_RGBA_UNORM_BLOCK

        public static final int VK_FORMAT_BC1_RGBA_UNORM_BLOCK
        A four-component, block compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized RGB image data, and provides 1 bit of alpha.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC1_RGBA_SRGB_BLOCK

        public static final int VK_FORMAT_BC1_RGBA_SRGB_BLOCK
        A four-component, block compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized RGB image data with sRGB nonlinear encoding, and provides 1 bit of alpha.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC2_UNORM_BLOCK

        public static final int VK_FORMAT_BC2_UNORM_BLOCK
        A four-component, block compressed format where each 4x4 block consists of 64-bits of unsigned normalized alpha image data followed by 64-bits of encoded unsigned normalized RGB image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC2_SRGB_BLOCK

        public static final int VK_FORMAT_BC2_SRGB_BLOCK
        A four-component, block compressed format where each 4x4 block consists of 64-bits of unsigned normalized alpha image data followed by 64-bits of encoded unsigned normalized RGB image data with sRGB nonlinear encoding.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC3_UNORM_BLOCK

        public static final int VK_FORMAT_BC3_UNORM_BLOCK
        A four-component, block compressed format where each 4x4 block consists of 64-bits of encoded alpha image data followed by 64-bits of encoded RGB image data. Both blocks are decoded as unsigned normalized values.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC3_SRGB_BLOCK

        public static final int VK_FORMAT_BC3_SRGB_BLOCK
        A four-component, block compressed format where each 4x4 block consists of 64-bits of encoded alpha image data followed by 64-bits of encoded RGB image data with sRGB nonlinear encoding. Both blocks are decoded as unsigned normalized values.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC4_UNORM_BLOCK

        public static final int VK_FORMAT_BC4_UNORM_BLOCK
        A one-component, block compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized red image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC4_SNORM_BLOCK

        public static final int VK_FORMAT_BC4_SNORM_BLOCK
        A one-component, block compressed format where each 4x4 block consists of 64-bits of encoded signed normalized red image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC5_UNORM_BLOCK

        public static final int VK_FORMAT_BC5_UNORM_BLOCK
        A two-component, block compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized red image data followed by 64-bits of encoded unsigned normalized green image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC5_SNORM_BLOCK

        public static final int VK_FORMAT_BC5_SNORM_BLOCK
        A two-component, block compressed format where each 4x4 block consists of 64-bits of encoded signed normalized red image data followed by 64-bits of encoded signed normalized green image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC6H_UFLOAT_BLOCK

        public static final int VK_FORMAT_BC6H_UFLOAT_BLOCK
        A three-component, block compressed format where each 4x4 block consists of 128-bits of encoded unsigned floating-point RGB image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC6H_SFLOAT_BLOCK

        public static final int VK_FORMAT_BC6H_SFLOAT_BLOCK
        A three-component, block compressed format where each 4x4 block consists of 128-bits of encoded signed floating-point RGB image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC7_UNORM_BLOCK

        public static final int VK_FORMAT_BC7_UNORM_BLOCK
        A four-component, block compressed format where each 4x4 block consists of 128-bits of encoded unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_BC7_SRGB_BLOCK

        public static final int VK_FORMAT_BC7_SRGB_BLOCK
        A four-component, block compressed format where each 4x4 block consists of 128-bits of encoded unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK

        public static final int VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK
        A three-component, ETC2 compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized RGB image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK

        public static final int VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
        A three-component, ETC2 compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized RGB image data with sRGB nonlinear encoding.
        See Also:
        Constant Field Values
      • VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK

        public static final int VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK
        A four-component, ETC2 compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized RGB image data, and provides 1 bit of alpha.
        See Also:
        Constant Field Values
      • VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK

        public static final int VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
        A four-component, ETC2 compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized RGB image data with sRGB nonlinear encoding, and provides 1 bit of alpha.
        See Also:
        Constant Field Values
      • VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK

        public static final int VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK
        A four-component, ETC2 compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized RGB image data, and 64-bits of encoded unsigned normalized alpha image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK

        public static final int VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
        A four-component, ETC2 compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized RGB image data with sRGB nonlinear encoding, and 64-bits of encoded unsigned normalized alpha image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_EAC_R11_UNORM_BLOCK

        public static final int VK_FORMAT_EAC_R11_UNORM_BLOCK
        A one-component, ETC2 compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized red image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_EAC_R11_SNORM_BLOCK

        public static final int VK_FORMAT_EAC_R11_SNORM_BLOCK
        A one-component, ETC2 compressed format where each 4x4 block consists of 64-bits of encoded signed normalized red image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_EAC_R11G11_UNORM_BLOCK

        public static final int VK_FORMAT_EAC_R11G11_UNORM_BLOCK
        A two-component, ETC2 compressed format where each 4x4 block consists of 64-bits of encoded unsigned normalized red image data followed by 64-bits of encoded unsigned normalized green image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_EAC_R11G11_SNORM_BLOCK

        public static final int VK_FORMAT_EAC_R11G11_SNORM_BLOCK
        A two-component, ETC2 compressed format where each 4x4 block consists of 64-bits of encoded signed normalized red image data followed by 64-bits of encoded signed normalized green image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_4x4_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_4x4_UNORM_BLOCK
        A four-component, ASTC compressed format where each 4x4 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_4x4_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_4x4_SRGB_BLOCK
        A four-component, ASTC compressed format where each 4x4 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_5x4_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_5x4_UNORM_BLOCK
        A four-component, ASTC compressed format where each 5x4 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_5x4_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_5x4_SRGB_BLOCK
        A four-component, ASTC compressed format where each 5x4 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_5x5_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_5x5_UNORM_BLOCK
        A four-component, ASTC compressed format where each 5x5 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_5x5_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_5x5_SRGB_BLOCK
        A four-component, ASTC compressed format where each 5x5 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_6x5_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_6x5_UNORM_BLOCK
        A four-component, ASTC compressed format where each 6x5 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_6x5_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_6x5_SRGB_BLOCK
        A four-component, ASTC compressed format where each 6x5 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_6x6_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_6x6_UNORM_BLOCK
        A four-component, ASTC compressed format where each 6x6 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_6x6_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_6x6_SRGB_BLOCK
        A four-component, ASTC compressed format where each 6x6 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_8x5_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_8x5_UNORM_BLOCK
        A four-component, ASTC compressed format where each 8x5 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_8x5_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_8x5_SRGB_BLOCK
        A four-component, ASTC compressed format where each 8x5 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_8x6_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_8x6_UNORM_BLOCK
        A four-component, ASTC compressed format where each 8x6 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_8x6_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_8x6_SRGB_BLOCK
        A four-component, ASTC compressed format where each 8x6 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_8x8_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_8x8_UNORM_BLOCK
        A four-component, ASTC compressed format where each 8x8 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_8x8_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_8x8_SRGB_BLOCK
        A four-component, ASTC compressed format where each 8x8 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_10x5_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_10x5_UNORM_BLOCK
        A four-component, ASTC compressed format where each 10x5 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_10x5_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_10x5_SRGB_BLOCK
        A four-component, ASTC compressed format where each 10x5 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_10x6_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_10x6_UNORM_BLOCK
        A four-component, ASTC compressed format where each 10x6 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_10x6_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_10x6_SRGB_BLOCK
        A four-component, ASTC compressed format where each 10x6 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_10x8_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_10x8_UNORM_BLOCK
        A four-component, ASTC compressed format where each 10x8 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_10x8_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_10x8_SRGB_BLOCK
        A four-component, ASTC compressed format where each 10x8 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_10x10_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_10x10_UNORM_BLOCK
        A four-component, ASTC compressed format where each 10x10 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_10x10_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_10x10_SRGB_BLOCK
        A four-component, ASTC compressed format where each 10x10 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_12x10_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_12x10_UNORM_BLOCK
        A four-component, ASTC compressed format where each 12x10 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_12x10_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_12x10_SRGB_BLOCK
        A four-component, ASTC compressed format where each 12x10 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_12x12_UNORM_BLOCK

        public static final int VK_FORMAT_ASTC_12x12_UNORM_BLOCK
        A four-component, ASTC compressed format where each 12x12 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data.
        See Also:
        Constant Field Values
      • VK_FORMAT_ASTC_12x12_SRGB_BLOCK

        public static final int VK_FORMAT_ASTC_12x12_SRGB_BLOCK
        A four-component, ASTC compressed format where each 12x12 block consists of 128-bits of encoded image data which is decoded as unsigned normalized RGBA image data with sRGB nonlinear encoding applied to the RGB components.
        See Also:
        Constant Field Values
      • VK_IMAGE_TYPE_1D

        public static final int VK_IMAGE_TYPE_1D
        One-dimensional image
        See Also:
        Constant Field Values
      • VK_IMAGE_TYPE_2D

        public static final int VK_IMAGE_TYPE_2D
        Two-dimensional image
        See Also:
        Constant Field Values
      • VK_IMAGE_TYPE_3D

        public static final int VK_IMAGE_TYPE_3D
        Three-dimensional image
        See Also:
        Constant Field Values
      • VK_IMAGE_TILING_OPTIMAL

        public static final int VK_IMAGE_TILING_OPTIMAL
        Specifies optimal tiling (texels are laid out in an implementation-dependent arrangement, for more optimal memory access).
        See Also:
        Constant Field Values
      • VK_IMAGE_TILING_LINEAR

        public static final int VK_IMAGE_TILING_LINEAR
        Specifies linear tiling (texels are laid out in memory in row-major order, possibly with some padding on each row).
        See Also:
        Constant Field Values
      • VK_PHYSICAL_DEVICE_TYPE_OTHER

        public static final int VK_PHYSICAL_DEVICE_TYPE_OTHER
        The device does not match any other available types.
        See Also:
        Constant Field Values
      • VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU

        public static final int VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU
        The device is typically one embedded in or tightly coupled with the host.
        See Also:
        Constant Field Values
      • VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU

        public static final int VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU
        The device is typically a separate processor connected to the host via an interlink.
        See Also:
        Constant Field Values
      • VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU

        public static final int VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU
        The device is typically a virtual node in a virtualization environment.
        See Also:
        Constant Field Values
      • VK_PHYSICAL_DEVICE_TYPE_CPU

        public static final int VK_PHYSICAL_DEVICE_TYPE_CPU
        The device is typically running on the same processors as the host.
        See Also:
        Constant Field Values
      • VK_QUERY_TYPE_OCCLUSION

        public static final int VK_QUERY_TYPE_OCCLUSION
        Occlusion query.
        See Also:
        Constant Field Values
      • VK_QUERY_TYPE_PIPELINE_STATISTICS

        public static final int VK_QUERY_TYPE_PIPELINE_STATISTICS
        Pipeline statistics query
        See Also:
        Constant Field Values
      • VK_QUERY_TYPE_TIMESTAMP

        public static final int VK_QUERY_TYPE_TIMESTAMP
        Timestamp query.
        See Also:
        Constant Field Values
      • VK_SHARING_MODE_EXCLUSIVE

        public static final int VK_SHARING_MODE_EXCLUSIVE
        Specifies that access to any range or image subresource of the object will be exclusive to a single queue family at a time.
        See Also:
        Constant Field Values
      • VK_SHARING_MODE_CONCURRENT

        public static final int VK_SHARING_MODE_CONCURRENT
        Specifies that concurrent access to any range or image subresource of the object from multiple queue families is supported.
        See Also:
        Constant Field Values
      • VK_IMAGE_LAYOUT_UNDEFINED

        public static final int VK_IMAGE_LAYOUT_UNDEFINED
        Supports no device access. This layout must only be used as an initialLayout or as the oldLayout in an image transition. When transitioning out of this layout, the contents of the memory are not guaranteed to be preserved.
        See Also:
        Constant Field Values
      • VK_IMAGE_LAYOUT_GENERAL

        public static final int VK_IMAGE_LAYOUT_GENERAL
        Supports all types of device access.
        See Also:
        Constant Field Values
      • VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL

        public static final int VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
        must only be used as a color or resolve attachment in a VkFramebuffer. This layout is valid only for image subresources of images created with the IMAGE_USAGE_COLOR_ATTACHMENT_BIT usage bit enabled.
        See Also:
        Constant Field Values
      • VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL

        public static final int VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
        must only be used as a depth/stencil attachment in a VkFramebuffer. This layout is valid only for image subresources of images created with the IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage bit enabled.
        See Also:
        Constant Field Values
      • VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL

        public static final int VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
        must only be used as a read-only depth/stencil attachment in a VkFramebuffer and/or as a read-only image in a shader (which can be read as a sampled image, combined image/sampler and/or input attachment). This layout is valid only for image subresources of images created with both the IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage bit enabled.
        See Also:
        Constant Field Values
      • VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

        public static final int VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
        must only be used as a read-only image in a shader (which can be read as a sampled image, combined image/sampler and/or input attachment). This layout is valid only for image subresources of images created with the IMAGE_USAGE_SAMPLED_BIT or IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage bit enabled.
        See Also:
        Constant Field Values
      • VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL

        public static final int VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
        must only be used as a destination image of a transfer command. This layout is valid only for image subresources of images created with the IMAGE_USAGE_TRANSFER_DST_BIT usage bit enabled.
        See Also:
        Constant Field Values
      • VK_IMAGE_LAYOUT_PREINITIALIZED

        public static final int VK_IMAGE_LAYOUT_PREINITIALIZED
        Supports no device access. This layout must only be used as an initialLayout or as the oldLayout in an image transition. When transitioning out of this layout, the contents of the memory are preserved. This layout is intended to be used as the initial layout for an image whose contents are written by the host, and hence the data can be written to memory immediately, without first executing a layout transition. Currently, IMAGE_LAYOUT_PREINITIALIZED is only useful with IMAGE_TILING_LINEAR images because there is not a standard layout defined for IMAGE_TILING_OPTIMAL images.
        See Also:
        Constant Field Values
      • VK_IMAGE_VIEW_TYPE_1D

        public static final int VK_IMAGE_VIEW_TYPE_1D
        One-dimensional image view.
        See Also:
        Constant Field Values
      • VK_IMAGE_VIEW_TYPE_2D

        public static final int VK_IMAGE_VIEW_TYPE_2D
        Two-dimensional image view.
        See Also:
        Constant Field Values
      • VK_IMAGE_VIEW_TYPE_3D

        public static final int VK_IMAGE_VIEW_TYPE_3D
        Three-dimensional image view.
        See Also:
        Constant Field Values
      • VK_IMAGE_VIEW_TYPE_CUBE

        public static final int VK_IMAGE_VIEW_TYPE_CUBE
        Cube map image view.
        See Also:
        Constant Field Values
      • VK_IMAGE_VIEW_TYPE_1D_ARRAY

        public static final int VK_IMAGE_VIEW_TYPE_1D_ARRAY
        One-dimensional array image view.
        See Also:
        Constant Field Values
      • VK_IMAGE_VIEW_TYPE_2D_ARRAY

        public static final int VK_IMAGE_VIEW_TYPE_2D_ARRAY
        Two-dimensional array image view.
        See Also:
        Constant Field Values
      • VK_IMAGE_VIEW_TYPE_CUBE_ARRAY

        public static final int VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
        Cube map array image view.
        See Also:
        Constant Field Values
      • VK_COMPONENT_SWIZZLE_IDENTITY

        public static final int VK_COMPONENT_SWIZZLE_IDENTITY
        The component is set to the identity swizzle.
        See Also:
        Constant Field Values
      • VK_COMPONENT_SWIZZLE_ZERO

        public static final int VK_COMPONENT_SWIZZLE_ZERO
        The component is set to zero.
        See Also:
        Constant Field Values
      • VK_COMPONENT_SWIZZLE_ONE

        public static final int VK_COMPONENT_SWIZZLE_ONE
        The component is set to either 1 or 1.0 depending on whether the type of the image view format is integer or floating-point respectively, as determined by the Format Definition section for each VkFormat.
        See Also:
        Constant Field Values
      • VK_COMPONENT_SWIZZLE_R

        public static final int VK_COMPONENT_SWIZZLE_R
        The component is set to the value of the R component of the image.
        See Also:
        Constant Field Values
      • VK_COMPONENT_SWIZZLE_G

        public static final int VK_COMPONENT_SWIZZLE_G
        The component is set to the value of the G component of the image.
        See Also:
        Constant Field Values
      • VK_COMPONENT_SWIZZLE_B

        public static final int VK_COMPONENT_SWIZZLE_B
        The component is set to the value of the B component of the image.
        See Also:
        Constant Field Values
      • VK_COMPONENT_SWIZZLE_A

        public static final int VK_COMPONENT_SWIZZLE_A
        The component is set to the value of the A component of the image.
        See Also:
        Constant Field Values
      • VK_VERTEX_INPUT_RATE_VERTEX

        public static final int VK_VERTEX_INPUT_RATE_VERTEX
        Indicates that vertex attribute addressing is a function of the vertex index.
        See Also:
        Constant Field Values
      • VK_VERTEX_INPUT_RATE_INSTANCE

        public static final int VK_VERTEX_INPUT_RATE_INSTANCE
        Indicates that vertex attribute addressing is a function of the instance index.
        See Also:
        Constant Field Values
      • VK_PRIMITIVE_TOPOLOGY_POINT_LIST

        public static final int VK_PRIMITIVE_TOPOLOGY_POINT_LIST
        A series of individual points. Each vertex defines a separate point.
        See Also:
        Constant Field Values
      • VK_PRIMITIVE_TOPOLOGY_LINE_LIST

        public static final int VK_PRIMITIVE_TOPOLOGY_LINE_LIST
        Individual line segments, each defined by a pair of vertices. The first two vertices define the first segment, with subsequent pairs of vertices each defining one more segment. If the number of vertices is odd, then the last vertex is ignored.
        See Also:
        Constant Field Values
      • VK_PRIMITIVE_TOPOLOGY_LINE_STRIP

        public static final int VK_PRIMITIVE_TOPOLOGY_LINE_STRIP
        A series of one or more connected line segments. In this case, the first vertex specifies the first segment’s start point while the second vertex specifies the first segment’s endpoint and the second segment’s start point. In general, the ith vertex (for i > 0) specifies the beginning of the ith segment and the end of the i−1st. The last vertex specifies the end of the last segment. If only one vertex is specified, then no primitive is generated.
        See Also:
        Constant Field Values
      • VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST

        public static final int VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST
        Separate triangles. In this case, vertices 3i, 3i + 1, and 3i + 2 (in that order) determine a triangle for each i = 0,1,…,n − 1, where there are 3n + k vertices drawn. k is either 0, 1, or 2; if k is not zero, the final k vertices are ignored.
        See Also:
        Constant Field Values
      • VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP

        public static final int VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP
        A triangle strip is a series of triangles connected along shared edges. In this case, the first three vertices define the first triangle, and their order is significant. Each subsequent vertex defines a new triangle using that point along with the last two vertices from the previous triangle. If fewer than three vertices are specified, no primitive is produced. The order of vertices in successive triangles changes, so that all triangle faces have the same orientation.
        See Also:
        Constant Field Values
      • VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN

        public static final int VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN
        A triangle fan. It is similar to a triangle strip, but changes the vertex replaced from the previous triangle, so that all triangles in the fan share a common vertex.
        See Also:
        Constant Field Values
      • VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY

        public static final int VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY
        Lines with adjacency are independent line segments where each endpoint has a corresponding adjacent vertex that is accessible in a geometry shader. If a geometry shader is not active, the adjacent vertices are ignored.

        A line segment is drawn from the 4i + 1st vertex to the 4i + 2nd vertex for each i = 0,1,…,n − 1, where there are 4n + k vertices. k is either 0, 1, 2, or 3; if k is not zero, the final k vertices are ignored. For line segment i, the 4ith and 4i + 3rd vertices are considered adjacent to the 4i + 1st and 4i + 2nd vertices, respectively.

        See Also:
        Constant Field Values
      • VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY

        public static final int VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY
        Line strips with adjacency are similar to line strips, except that each line segment has a pair of adjacent vertices that are accessible in a geometry shader. If a geometry shader is not active, the adjacent vertices are ignored.

        A line segment is drawn from the i + 1st vertex to the i + 2nd vertex for each i = 0,1,…,n − 1, where there are n + 3 vertices. If there are fewer than four vertices, all vertices are ignored. For line segment i, the ith and i + 3rd vertex are considered adjacent to the i + 1st and i + 2nd vertices, respectively.

        See Also:
        Constant Field Values
      • VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY

        public static final int VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY
        Triangles with adjacency are similar to separate triangles except that each triangle edge has an adjacent vertex that is accessible in a geometry shader. If a geometry shader is not active, the adjacent vertices are ignored.

        The 6ith, 6i + 2nd, and 6i + 4th vertices (in that order) determine a triangle for each i = 0,1,…,n − 1, where there are 6n + k vertices. k is either 0, 1, 2, 3, 4, or 5; if k is non-zero, the final k vertices are ignored. For triangle i, the 6i + 1st, 6i + 3rd, and 6i + 5th vertices are considered adjacent to edges from the 6ith to the 6i + 2nd, from the 6i + 2nd to the 6i + 4th, and from the 6i + 4th to the 6ith vertices, respectively.

        See Also:
        Constant Field Values
      • VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY

        public static final int VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY
        Triangle strips with adjacency are similar to triangle strips except that each triangle edge has an adjacent vertex that is accessible in a geometry shader. If a geometry shader is not active, the adjacent vertices are ignored.

        In triangle strips with adjacency, n triangles are drawn where there are 2(n + 2) + k vertices. k is either 0 or 1; if k is 1, the final vertex is ignored. If there are fewer than 6 vertices, the entire primitive is ignored. The table below describes the vertices and order used to draw each triangle, and which vertices are considered adjacent to each edge of the triangle:

        Primitive VerticesAdjacent Vertices
        Primitive1st2nd3rd1/22/33/1
        only ( i = 0 , n = 1 )024153
        first ( i = 0 )024163
        middle ( i odd)2i+22i2i+42i−22i+32i+6
        middle ( i even)2i2i+22i+42i−22i+62i+3
        last ( i = n − 1 , i odd)2i+22i2i+42i−22i+32i+5
        last ( i = n − 1 , i even)2i2i+22i+42i−22i+52i+3
        See Also:
        Constant Field Values
      • VK_PRIMITIVE_TOPOLOGY_PATCH_LIST

        public static final int VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
        Separate patches. A patch is an ordered collection of vertices used for primitive tessellation. The vertices comprising a patch have no implied geometric ordering, and are used by tessellation shaders and the fixed-function tessellator to generate new point, line, or triangle primitives.

        Each patch in the series has a fixed number of vertices, specified by the patchControlPoints member of the VkPipelineTessellationStateCreateInfo structure passed to CreateGraphicsPipelines. Once assembled and vertex shaded, these patches are provided as input to the tessellation control shader stage.

        If the number of vertices in a patch is given by v, the vith through vi + v − 1st vertices (in that order) determine a patch for each i = 0,1,…n − 1, where there are vn + k vertices. k is in the range [0,v − 1] ; if k is not zero, the final k vertices are ignored.

        See Also:
        Constant Field Values
      • VK_POLYGON_MODE_FILL

        public static final int VK_POLYGON_MODE_FILL
        Causes polygons to render using the polygon rasterization rules.
        See Also:
        Constant Field Values
      • VK_POLYGON_MODE_LINE

        public static final int VK_POLYGON_MODE_LINE
        Causes polygon edges to be drawn as line segments.
        See Also:
        Constant Field Values
      • VK_POLYGON_MODE_POINT

        public static final int VK_POLYGON_MODE_POINT
        The vertices of polygons are treated, for rasterization purposes, as if they had been drawn as points.
        See Also:
        Constant Field Values
      • VK_FRONT_FACE_COUNTER_CLOCKWISE

        public static final int VK_FRONT_FACE_COUNTER_CLOCKWISE
        A triangle with positive area is considered front-facing.
        See Also:
        Constant Field Values
      • VK_FRONT_FACE_CLOCKWISE

        public static final int VK_FRONT_FACE_CLOCKWISE
        A triangle with negative area is considered front-facing.
        See Also:
        Constant Field Values
      • VK_COMPARE_OP_NEVER

        public static final int VK_COMPARE_OP_NEVER
        The test never passes.
        See Also:
        Constant Field Values
      • VK_COMPARE_OP_LESS

        public static final int VK_COMPARE_OP_LESS
        The test passes when R < S.
        See Also:
        Constant Field Values
      • VK_COMPARE_OP_EQUAL

        public static final int VK_COMPARE_OP_EQUAL
        The test passes when R = S
        See Also:
        Constant Field Values
      • VK_COMPARE_OP_LESS_OR_EQUAL

        public static final int VK_COMPARE_OP_LESS_OR_EQUAL
        The test passes when RS.
        See Also:
        Constant Field Values
      • VK_COMPARE_OP_GREATER

        public static final int VK_COMPARE_OP_GREATER
        The test passes when R > S.
        See Also:
        Constant Field Values
      • VK_COMPARE_OP_NOT_EQUAL

        public static final int VK_COMPARE_OP_NOT_EQUAL
        The test passes when RS.
        See Also:
        Constant Field Values
      • VK_COMPARE_OP_GREATER_OR_EQUAL

        public static final int VK_COMPARE_OP_GREATER_OR_EQUAL
        The test passes when RS.
        See Also:
        Constant Field Values
      • VK_COMPARE_OP_ALWAYS

        public static final int VK_COMPARE_OP_ALWAYS
        The test always passes.
        See Also:
        Constant Field Values
      • VK_STENCIL_OP_KEEP

        public static final int VK_STENCIL_OP_KEEP
        Keeps the current value.
        See Also:
        Constant Field Values
      • VK_STENCIL_OP_ZERO

        public static final int VK_STENCIL_OP_ZERO
        Sets the value to 0.
        See Also:
        Constant Field Values
      • VK_STENCIL_OP_REPLACE

        public static final int VK_STENCIL_OP_REPLACE
        Sets the value to reference.
        See Also:
        Constant Field Values
      • VK_STENCIL_OP_INCREMENT_AND_CLAMP

        public static final int VK_STENCIL_OP_INCREMENT_AND_CLAMP
        Increments the current value and clamps to the maximum representable unsigned value.
        See Also:
        Constant Field Values
      • VK_STENCIL_OP_DECREMENT_AND_CLAMP

        public static final int VK_STENCIL_OP_DECREMENT_AND_CLAMP
        Decrements the current value and clamps to 0.
        See Also:
        Constant Field Values
      • VK_STENCIL_OP_INVERT

        public static final int VK_STENCIL_OP_INVERT
        Bitwise-inverts the current value.
        See Also:
        Constant Field Values
      • VK_STENCIL_OP_INCREMENT_AND_WRAP

        public static final int VK_STENCIL_OP_INCREMENT_AND_WRAP
        Increments the current value and wraps to 0 when the maximum value would have been exceeded.
        See Also:
        Constant Field Values
      • VK_STENCIL_OP_DECREMENT_AND_WRAP

        public static final int VK_STENCIL_OP_DECREMENT_AND_WRAP
        Decrements the current value and wraps to the maximum possible value when the value would go below 0.
        See Also:
        Constant Field Values
      • VK_LOGIC_OP_AND_REVERSE

        public static final int VK_LOGIC_OP_AND_REVERSE
        s∧¬d
        See Also:
        Constant Field Values
      • VK_LOGIC_OP_AND_INVERTED

        public static final int VK_LOGIC_OP_AND_INVERTED
        ¬s∧d
        See Also:
        Constant Field Values
      • VK_LOGIC_OP_EQUIVALENT

        public static final int VK_LOGIC_OP_EQUIVALENT
        ¬(s⊕d)
        See Also:
        Constant Field Values
      • VK_LOGIC_OP_OR_REVERSE

        public static final int VK_LOGIC_OP_OR_REVERSE
        s∨¬d
        See Also:
        Constant Field Values
      • VK_LOGIC_OP_COPY_INVERTED

        public static final int VK_LOGIC_OP_COPY_INVERTED
        ¬s
        See Also:
        Constant Field Values
      • VK_LOGIC_OP_OR_INVERTED

        public static final int VK_LOGIC_OP_OR_INVERTED
        ¬s∨d
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_ZERO

        public static final int VK_BLEND_FACTOR_ZERO
        (0, 0, 0, 0)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_ONE

        public static final int VK_BLEND_FACTOR_ONE
        (1, 1, 1, 1)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_SRC_COLOR

        public static final int VK_BLEND_FACTOR_SRC_COLOR
        (Rs0, Gs0, Bs0, As0)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR

        public static final int VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR
        (1 − Rs0, 1 − Gs0, 1 − Bs0, 1 − As0)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_DST_COLOR

        public static final int VK_BLEND_FACTOR_DST_COLOR
        (Rd, Gd, Bd, Ad)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR

        public static final int VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR
        (1 − Rd, 1 − Gd, 1 − Bd, 1 − Ad)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_SRC_ALPHA

        public static final int VK_BLEND_FACTOR_SRC_ALPHA
        (As0, As0, As0, As0)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA

        public static final int VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
        (1 − As0, 1 − As0, 1 − As0, 1 − As0)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_DST_ALPHA

        public static final int VK_BLEND_FACTOR_DST_ALPHA
        (Ad, Ad, Ad, Ad)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA

        public static final int VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA
        (1 − Ad, 1 − Ad, 1 − Ad, 1 − Ad)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_CONSTANT_COLOR

        public static final int VK_BLEND_FACTOR_CONSTANT_COLOR
        (Rc, Gc, Bc, Ac)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR

        public static final int VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR
        (1 − Rc, 1 − Gc, 1 − Bc, 1 − Ac)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_CONSTANT_ALPHA

        public static final int VK_BLEND_FACTOR_CONSTANT_ALPHA
        (Ac, Ac, Ac, Ac)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA

        public static final int VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA
        (1 − Ac, 1 − Ac, 1 − Ac, 1 − Ac)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_SRC_ALPHA_SATURATE

        public static final int VK_BLEND_FACTOR_SRC_ALPHA_SATURATE
        (f, f, f, 1) ; f = min(As0, 1 − Ad)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_SRC1_COLOR

        public static final int VK_BLEND_FACTOR_SRC1_COLOR
        (Rs1, Gs1, Bs1, As1)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR

        public static final int VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR
        (1 − Rs1, 1 − Gs1, 1 − Bs1, 1 − As1)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_SRC1_ALPHA

        public static final int VK_BLEND_FACTOR_SRC1_ALPHA
        (As1, As1, As1, As1)
        See Also:
        Constant Field Values
      • VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA

        public static final int VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
        (1 − As1, 1 − As1, 1 − As1, 1 − As1)
        See Also:
        Constant Field Values
      • VK_BLEND_OP_ADD

        public static final int VK_BLEND_OP_ADD
        R = Rs0 × Sr + Rd × Dr
        G = Gs0 × Sg + Gd × Dg
        B = Bs0 × Sb + Bd × Db
        A = As0 × Sa + Ad × Da
        See Also:
        Constant Field Values
      • VK_BLEND_OP_SUBTRACT

        public static final int VK_BLEND_OP_SUBTRACT
        R = Rs0 × Sr − Rd × Dr
        G = Gs0 × Sg − Gd × Dg
        B = Bs0 × Sb − Bd × Db
        A = As0 × Sa − Ad × Da
        See Also:
        Constant Field Values
      • VK_BLEND_OP_REVERSE_SUBTRACT

        public static final int VK_BLEND_OP_REVERSE_SUBTRACT
        R = Rd × Dr − Rs0 × Sr
        G = Gd × Dg − Gs0 × Sg
        B = Bd × Db − Bs0 × Sb
        A = Ad × Da − As0 × Sa
        See Also:
        Constant Field Values
      • VK_BLEND_OP_MIN

        public static final int VK_BLEND_OP_MIN
        R = min(Rs0, Rd)
        G = min(Gs0, Gd)
        B = min(Bs0, Bd)
        A = min(As0, Ad)
        See Also:
        Constant Field Values
      • VK_BLEND_OP_MAX

        public static final int VK_BLEND_OP_MAX
        R = max(Rs0, Rd)
        G = max(Gs0, Gd)
        B = max(Bs0, Bd)
        A = max(As0, Ad)
        See Also:
        Constant Field Values
      • VK_DYNAMIC_STATE_VIEWPORT

        public static final int VK_DYNAMIC_STATE_VIEWPORT
        Indicates that the pViewports state in VkPipelineViewportStateCreateInfo will be ignored and must be set dynamically with CmdSetViewport before any draw commands. The number of viewports used by a pipeline is still specified by the viewportCount member of VkPipelineViewportStateCreateInfo.
        See Also:
        Constant Field Values
      • VK_DYNAMIC_STATE_SCISSOR

        public static final int VK_DYNAMIC_STATE_SCISSOR
        Indicates that the pScissors state in VkPipelineViewportStateCreateInfo will be ignored and must be set dynamically with CmdSetScissor before any draw commands. The number of scissor rectangles used by a pipeline is still specified by the scissorCount member of VkPipelineViewportStateCreateInfo.
        See Also:
        Constant Field Values
      • VK_DYNAMIC_STATE_DEPTH_BIAS

        public static final int VK_DYNAMIC_STATE_DEPTH_BIAS
        Indicates that the depthBiasConstantFactor, depthBiasClamp and depthBiasSlopeFactor states in VkPipelineRasterizationStateCreateInfo will be ignored and must be set dynamically with CmdSetDepthBias before any draws are performed with depthBiasEnable in VkPipelineRasterizationStateCreateInfo set to TRUE.
        See Also:
        Constant Field Values
      • VK_DYNAMIC_STATE_BLEND_CONSTANTS

        public static final int VK_DYNAMIC_STATE_BLEND_CONSTANTS
        Indicates that the blendConstants state in VkPipelineColorBlendStateCreateInfo will be ignored and must be set dynamically with CmdSetBlendConstants before any draws are performed with a pipeline state with VkPipelineColorBlendAttachmentState member blendEnable set to TRUE and any of the blend functions using a constant blend color.
        See Also:
        Constant Field Values
      • VK_DYNAMIC_STATE_DEPTH_BOUNDS

        public static final int VK_DYNAMIC_STATE_DEPTH_BOUNDS
        Indicates that the minDepthBounds and maxDepthBounds states of VkPipelineDepthStencilStateCreateInfo will be ignored and must be set dynamically with CmdSetDepthBounds before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member depthBoundsTestEnable set to TRUE.
        See Also:
        Constant Field Values
      • VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK

        public static final int VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK
        Indicates that the compareMask state in VkPipelineDepthStencilStateCreateInfo for both front and back will be ignored and must be set dynamically with CmdSetStencilCompareMask before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member stencilTestEnable set to TRUE.
        See Also:
        Constant Field Values
      • VK_DYNAMIC_STATE_STENCIL_WRITE_MASK

        public static final int VK_DYNAMIC_STATE_STENCIL_WRITE_MASK
        Indicates that the writeMask state in VkPipelineDepthStencilStateCreateInfo for both front and back will be ignored and must be set dynamically with CmdSetStencilWriteMask before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member stencilTestEnable set to TRUE.
        See Also:
        Constant Field Values
      • VK_DYNAMIC_STATE_STENCIL_REFERENCE

        public static final int VK_DYNAMIC_STATE_STENCIL_REFERENCE
        Indicates that the reference state in VkPipelineDepthStencilStateCreateInfo for both front and back will be ignored and must be set dynamically with CmdSetStencilReference before any draws are performed with a pipeline state with VkPipelineDepthStencilStateCreateInfo member stencilTestEnable set to TRUE.
        See Also:
        Constant Field Values
      • VK_FILTER_NEAREST

        public static final int VK_FILTER_NEAREST
        Nearest filtering.

        Computes the integer texel coordinates that the unnormalized coordinates lie within:

        i = floor(u)
        j = floor(v)
        k = floor(w)
        See Also:
        Constant Field Values
      • VK_FILTER_LINEAR

        public static final int VK_FILTER_LINEAR
        Linear filtering.

        Computes a set of neighboring coordinates which bound the unnormalized coordinates. The integer texel coordinates are combinations of i0 or i1, j0 or j1, k0 or k1, as well as weights α, β, and γ.

        i0 = floor(u - 0.5)      i1 = i0 + 1
        j0 = floor(v - 0.5)      j1 = j0 + 1
        k0 = floor(w - 0.5)      k1 = k0 + 1
        
        α = frac(u - 0.5)
        β = frac(v - 0.5)
        γ = frac(w - 0.5)
        See Also:
        Constant Field Values
      • VK_SAMPLER_MIPMAP_MODE_NEAREST

        public static final int VK_SAMPLER_MIPMAP_MODE_NEAREST
        Texels are read from the image level d, where:
        d = levelbasewhen λ ≤ 0.5
        d = nearest(λ)when λ > 0.5 && levelbase + λ ≤ q + 0.5
        d = qwhen λ > 0.5 && levelbase + λ > q + 0.5

        and:

        nearest(λ) = ceil(levelbase + λ + 0.5) - 1,preferred
        nearest(λ) = floor(levelbase + λ + 0.5),alternative

        and where q is the levelCount from the subresourceRange of the image view.

        See Also:
        Constant Field Values
      • VK_SAMPLER_MIPMAP_MODE_LINEAR

        public static final int VK_SAMPLER_MIPMAP_MODE_LINEAR
        Texels are read from image levels dhi and dlo, where:
        dhi = qwhen levelbase + λ ≥ q
        dhi = floor(levelbase + λ)otherwise

        and:

        dlo = qwhen levelbase + λ ≥ q
        dlo = dhi + 1otherwise

        δ = frac(λ) is the fractional value used for linear filtering between levels:

        See Also:
        Constant Field Values
      • VK_SAMPLER_ADDRESS_MODE_REPEAT

        public static final int VK_SAMPLER_ADDRESS_MODE_REPEAT
        Indicates that the repeat wrap mode will be used.
        See Also:
        Constant Field Values
      • VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT

        public static final int VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT
        Indicates that the mirrored repeat wrap mode will be used.
        See Also:
        Constant Field Values
      • VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE

        public static final int VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE
        Indicates that the clamp to edge wrap mode will be used.
        See Also:
        Constant Field Values
      • VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER

        public static final int VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER
        Indicates that the clamp to border wrap mode will be used.
        See Also:
        Constant Field Values
      • VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK

        public static final int VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK
        (0.0, 0.0, 0.0, 0.0)
        See Also:
        Constant Field Values
      • VK_BORDER_COLOR_INT_TRANSPARENT_BLACK

        public static final int VK_BORDER_COLOR_INT_TRANSPARENT_BLACK
        (0, 0, 0, 0)
        See Also:
        Constant Field Values
      • VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK

        public static final int VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK
        (0.0, 0.0, 0.0, 1.0)
        See Also:
        Constant Field Values
      • VK_BORDER_COLOR_INT_OPAQUE_BLACK

        public static final int VK_BORDER_COLOR_INT_OPAQUE_BLACK
        (0, 0, 0, 1)
        See Also:
        Constant Field Values
      • VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE

        public static final int VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE
        (1.0, 1.0, 1.0, 1.0)
        See Also:
        Constant Field Values
      • VK_BORDER_COLOR_INT_OPAQUE_WHITE

        public static final int VK_BORDER_COLOR_INT_OPAQUE_WHITE
        (1, 1, 1, 1)
        See Also:
        Constant Field Values
      • VK_DESCRIPTOR_TYPE_SAMPLER

        public static final int VK_DESCRIPTOR_TYPE_SAMPLER
        VkDescriptorType
        See Also:
        Constant Field Values
      • VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER

        public static final int VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
        VkDescriptorType
        See Also:
        Constant Field Values
      • VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE

        public static final int VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
        VkDescriptorType
        See Also:
        Constant Field Values
      • VK_DESCRIPTOR_TYPE_STORAGE_IMAGE

        public static final int VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
        VkDescriptorType
        See Also:
        Constant Field Values
      • VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER

        public static final int VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER
        VkDescriptorType
        See Also:
        Constant Field Values
      • VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER

        public static final int VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER
        VkDescriptorType
        See Also:
        Constant Field Values
      • VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER

        public static final int VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
        VkDescriptorType
        See Also:
        Constant Field Values
      • VK_DESCRIPTOR_TYPE_STORAGE_BUFFER

        public static final int VK_DESCRIPTOR_TYPE_STORAGE_BUFFER
        VkDescriptorType
        See Also:
        Constant Field Values
      • VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC

        public static final int VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
        VkDescriptorType
        See Also:
        Constant Field Values
      • VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC

        public static final int VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC
        VkDescriptorType
        See Also:
        Constant Field Values
      • VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT

        public static final int VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
        VkDescriptorType
        See Also:
        Constant Field Values
      • VK_ATTACHMENT_LOAD_OP_LOAD

        public static final int VK_ATTACHMENT_LOAD_OP_LOAD
        Means the contents within the render area will be preserved.
        See Also:
        Constant Field Values
      • VK_ATTACHMENT_LOAD_OP_CLEAR

        public static final int VK_ATTACHMENT_LOAD_OP_CLEAR
        Means the contents within the render area will be cleared to a uniform value, which is specified when a render pass instance is begun.
        See Also:
        Constant Field Values
      • VK_ATTACHMENT_LOAD_OP_DONT_CARE

        public static final int VK_ATTACHMENT_LOAD_OP_DONT_CARE
        Means the contents within the area need not be preserved; the contents of the attachment will be undefined inside the render area.
        See Also:
        Constant Field Values
      • VK_ATTACHMENT_STORE_OP_DONT_CARE

        public static final int VK_ATTACHMENT_STORE_OP_DONT_CARE
        Means the contents within the render area are not needed after rendering, and may be discarded; the contents of the attachment will be undefined inside the render area.
        See Also:
        Constant Field Values
      • VK_PIPELINE_BIND_POINT_GRAPHICS

        public static final int VK_PIPELINE_BIND_POINT_GRAPHICS
        VkPipelineBindPoint
        See Also:
        Constant Field Values
      • VK_PIPELINE_BIND_POINT_COMPUTE

        public static final int VK_PIPELINE_BIND_POINT_COMPUTE
        VkPipelineBindPoint
        See Also:
        Constant Field Values
      • VK_COMMAND_BUFFER_LEVEL_PRIMARY

        public static final int VK_COMMAND_BUFFER_LEVEL_PRIMARY
        VkCommandBufferLevel
        See Also:
        Constant Field Values
      • VK_COMMAND_BUFFER_LEVEL_SECONDARY

        public static final int VK_COMMAND_BUFFER_LEVEL_SECONDARY
        VkCommandBufferLevel
        See Also:
        Constant Field Values
      • VK_INDEX_TYPE_UINT16

        public static final int VK_INDEX_TYPE_UINT16
        VkIndexType
        See Also:
        Constant Field Values
      • VK_INDEX_TYPE_UINT32

        public static final int VK_INDEX_TYPE_UINT32
        VkIndexType
        See Also:
        Constant Field Values
      • VK_SUBPASS_CONTENTS_INLINE

        public static final int VK_SUBPASS_CONTENTS_INLINE
        The contents of the subpass will be recorded inline in the primary command buffer, and secondary command buffers must not be executed within the subpass.
        See Also:
        Constant Field Values
      • VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS

        public static final int VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
        The contents are recorded in secondary command buffers that will be called from the primary command buffer, and CmdExecuteCommands is the only valid command on the command buffer until CmdNextSubpass or CmdEndRenderPass.
        See Also:
        Constant Field Values
      • VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT

        public static final int VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
        VkImageView can be sampled from.
        See Also:
        Constant Field Values
      • VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT

        public static final int VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
        VkImageView can be used as storage image.
        See Also:
        Constant Field Values
      • VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT

        public static final int VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
        VkImageView can be used as storage image that supports atomic operations.
        See Also:
        Constant Field Values
      • VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT

        public static final int VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
        VkImageView can be used as a framebuffer color attachment and as an input attachment.
        See Also:
        Constant Field Values
      • VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT

        public static final int VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT
        VkImageView can be used as a framebuffer color attachment that supports blending and as an input attachment.
        See Also:
        Constant Field Values
      • VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT

        public static final int VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
        VkImageView can be used as a framebuffer depth/stencil attachment and as an input attachment.
        See Also:
        Constant Field Values
      • VK_FORMAT_FEATURE_BLIT_SRC_BIT

        public static final int VK_FORMAT_FEATURE_BLIT_SRC_BIT
        VkImage can be used as srcImage for the CmdBlitImage command.
        See Also:
        Constant Field Values
      • VK_FORMAT_FEATURE_BLIT_DST_BIT

        public static final int VK_FORMAT_FEATURE_BLIT_DST_BIT
        VkImage can be used as dstImage for the CmdBlitImage command.
        See Also:
        Constant Field Values
      • VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT

        public static final int VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
        If FORMAT_FEATURE_SAMPLED_IMAGE_BIT is also set, VkImageView can be used with a sampler that has either of magFilter or minFilter set to FILTER_LINEAR, or mipmapMode set to SAMPLER_MIPMAP_MODE_LINEAR. If FORMAT_FEATURE_BLIT_SRC_BIT is also set, VkImage can be used as the srcImage to CmdBlitImage with a filter of FILTER_LINEAR. This bit must only be exposed for formats that also support the FORMAT_FEATURE_SAMPLED_IMAGE_BIT or FORMAT_FEATURE_BLIT_SRC_BIT.

        If the format being queried is a depth/stencil format, this bit only indicates that the depth aspect (not the stencil aspect) supports linear filtering, and that linear filtering of the depth aspect is supported whether depth compare is enabled in the sampler or not. If this bit is not present, linear filtering with depth compare disabled is unsupported and linear filtering with depth compare enabled is supported, but may compute the filtered value in an implementation-dependent manner which differs from the normal rules of linear filtering. The resulting value must be in the range [0,1] and should be proportional to, or a weighted average of, the number of comparison passes or failures.

        See Also:
        Constant Field Values
      • VK_IMAGE_USAGE_TRANSFER_SRC_BIT

        public static final int VK_IMAGE_USAGE_TRANSFER_SRC_BIT
        Indicates that the image can be used as the source of a transfer command.
        See Also:
        Constant Field Values
      • VK_IMAGE_USAGE_TRANSFER_DST_BIT

        public static final int VK_IMAGE_USAGE_TRANSFER_DST_BIT
        Indicates that the image can be used as the destination of a transfer command.
        See Also:
        Constant Field Values
      • VK_IMAGE_USAGE_STORAGE_BIT

        public static final int VK_IMAGE_USAGE_STORAGE_BIT
        Indicates that the image can be used to create a VkImageView suitable for occupying a VkDescriptorSet slot of type DESCRIPTOR_TYPE_STORAGE_IMAGE.
        See Also:
        Constant Field Values
      • VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT

        public static final int VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
        Indicates that the image can be used to create a VkImageView suitable for use as a color or resolve attachment in a VkFramebuffer.
        See Also:
        Constant Field Values
      • VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT

        public static final int VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
        Indicates that the image can be used to create a VkImageView suitable for use as a depth/stencil attachment in a VkFramebuffer.
        See Also:
        Constant Field Values
      • VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT

        public static final int VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
        Indicates that the image can be used to create a VkImageView suitable for occupying VkDescriptorSet slot of type DESCRIPTOR_TYPE_INPUT_ATTACHMENT; be read from a shader as an input attachment; and be used as an input attachment in a framebuffer.
        See Also:
        Constant Field Values
      • VK_IMAGE_CREATE_SPARSE_BINDING_BIT

        public static final int VK_IMAGE_CREATE_SPARSE_BINDING_BIT
        Indicates that the image will be backed using sparse memory binding.
        See Also:
        Constant Field Values
      • VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT

        public static final int VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
        Indicates that the image can be partially backed using sparse memory binding. Images created with this flag must also be created with the IMAGE_CREATE_SPARSE_BINDING_BIT flag.
        See Also:
        Constant Field Values
      • VK_IMAGE_CREATE_SPARSE_ALIASED_BIT

        public static final int VK_IMAGE_CREATE_SPARSE_ALIASED_BIT
        Indicates that the image will be backed using sparse memory binding with memory ranges that might also simultaneously be backing another image (or another portion of the same image). Images created with this flag must also be created with the IMAGE_CREATE_SPARSE_BINDING_BIT flag.
        See Also:
        Constant Field Values
      • VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT

        public static final int VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
        Indicates that the image can be used to create a VkImageView with a different format from the image.
        See Also:
        Constant Field Values
      • VK_SAMPLE_COUNT_1_BIT

        public static final int VK_SAMPLE_COUNT_1_BIT
        1 sample per pixel. Standard sample locations:
        (0.5, 0.5)
        See Also:
        Constant Field Values
      • VK_SAMPLE_COUNT_2_BIT

        public static final int VK_SAMPLE_COUNT_2_BIT
        2 samples per pixel. Standard sample locations:
        (0.25, 0.25)
        (0.75, 0.75)
        See Also:
        Constant Field Values
      • VK_SAMPLE_COUNT_4_BIT

        public static final int VK_SAMPLE_COUNT_4_BIT
        4 samples per pixel. Standard sample locations:
        (0.375, 0.125)
        (0.875, 0.375)
        (0.125, 0.625)
        (0.625, 0.875)
        See Also:
        Constant Field Values
      • VK_SAMPLE_COUNT_8_BIT

        public static final int VK_SAMPLE_COUNT_8_BIT
        8 samples per pixel. Standard sample locations:
        (0.5625, 0.3125)
        (0.4375, 0.6875)
        (0.8125, 0.5625)
        (0.3125, 0.1875)
        (0.1875, 0.8125)
        (0.0625, 0.4375)
        (0.6875, 0.9375)
        (0.9375, 0.0625)
        See Also:
        Constant Field Values
      • VK_SAMPLE_COUNT_16_BIT

        public static final int VK_SAMPLE_COUNT_16_BIT
        16 samples per pixel. Standard sample locations:
        (0.5625, 0.5625)
        (0.4375, 0.3125)
        (0.3125, 0.625)
        (0.75, 0.4375)
        (0.1875, 0.375)
        (0.625, 0.8125)
        (0.8125, 0.6875)
        (0.6875, 0.1875)
        (0.375, 0.875)
        (0.5, 0.0625)
        (0.25, 0.125)
        (0.125, 0.75)
        (0.0, 0.5)
        (0.9375, 0.25)
        (0.875, 0.9375)
        (0.0625, 0.0)
        See Also:
        Constant Field Values
      • VK_SAMPLE_COUNT_32_BIT

        public static final int VK_SAMPLE_COUNT_32_BIT
        32 samples per pixel.
        See Also:
        Constant Field Values
      • VK_SAMPLE_COUNT_64_BIT

        public static final int VK_SAMPLE_COUNT_64_BIT
        64 samples per pixel.
        See Also:
        Constant Field Values
      • VK_QUEUE_GRAPHICS_BIT

        public static final int VK_QUEUE_GRAPHICS_BIT
        If set, then the queues in this queue family support graphics operations.
        See Also:
        Constant Field Values
      • VK_QUEUE_COMPUTE_BIT

        public static final int VK_QUEUE_COMPUTE_BIT
        If set, then the queues in this queue family support compute operations.
        See Also:
        Constant Field Values
      • VK_QUEUE_TRANSFER_BIT

        public static final int VK_QUEUE_TRANSFER_BIT
        If set, then the queues in this queue family support transfer operations.
        See Also:
        Constant Field Values
      • VK_QUEUE_SPARSE_BINDING_BIT

        public static final int VK_QUEUE_SPARSE_BINDING_BIT
        If set, then the queues in this queue family support sparse memory management operations. If any of the sparse resource features are enabled, then at least one queue family must support this bit.
        See Also:
        Constant Field Values
      • VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT

        public static final int VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
        If set, memory allocated with this type is the most efficient for device access. This property will only be set for memory types belonging to heaps with the MEMORY_HEAP_DEVICE_LOCAL_BIT set.
        See Also:
        Constant Field Values
      • VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT

        public static final int VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
        If set, memory allocated with this type can be mapped using MapMemory so that it can be accessed on the host.
        See Also:
        Constant Field Values
      • VK_MEMORY_PROPERTY_HOST_CACHED_BIT

        public static final int VK_MEMORY_PROPERTY_HOST_CACHED_BIT
        If set, memory allocated with this type is cached on the host. Host memory accesses to uncached memory are slower than to cached memory, however uncached memory is always host coherent.
        See Also:
        Constant Field Values
      • VK_MEMORY_HEAP_DEVICE_LOCAL_BIT

        public static final int VK_MEMORY_HEAP_DEVICE_LOCAL_BIT
        Means the heap corresponds to device local memory. Device local memory may have different performance characteristics than host local memory, and may support different memory property flags.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT

        public static final int VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
        Stage of the pipeline where commands are initially received by the queue.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT

        public static final int VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
        Stage of the pipeline where Draw/DispatchIndirect data structures are consumed.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_VERTEX_INPUT_BIT

        public static final int VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
        Stage of the pipeline where vertex and index buffers are consumed.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_VERTEX_SHADER_BIT

        public static final int VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
        Vertex shader stage.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT

        public static final int VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
        Tessellation control shader stage.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT

        public static final int VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
        Tessellation evaluation shader stage.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT

        public static final int VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
        Geometry shader stage.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT

        public static final int VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
        Fragment shader stage.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT

        public static final int VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
        Stage of the pipeline where early fragment tests (depth and stencil tests before fragment shading) are performed.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT

        public static final int VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
        Stage of the pipeline where late fragment tests (depth and stencil tests after fragment shading) are performed.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT

        public static final int VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
        Stage of the pipeline after blending where the final color values are output from the pipeline. This stage also includes resolve operations that occur at the end of a subpass. Note that this does not necessarily indicate that the values have been committed to memory.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT

        public static final int VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
        Execution of a compute shader.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT

        public static final int VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT
        Final stage in the pipeline where commands complete execution.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_HOST_BIT

        public static final int VK_PIPELINE_STAGE_HOST_BIT
        A pseudo-stage indicating execution on the host of reads/writes of device memory.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT

        public static final int VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT
        Execution of all graphics pipeline stages.
        See Also:
        Constant Field Values
      • VK_PIPELINE_STAGE_ALL_COMMANDS_BIT

        public static final int VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
        Execution of all stages supported on the queue.
        See Also:
        Constant Field Values
      • VK_IMAGE_ASPECT_COLOR_BIT

        public static final int VK_IMAGE_ASPECT_COLOR_BIT
        VkImageAspectFlagBits
        See Also:
        Constant Field Values
      • VK_IMAGE_ASPECT_DEPTH_BIT

        public static final int VK_IMAGE_ASPECT_DEPTH_BIT
        VkImageAspectFlagBits
        See Also:
        Constant Field Values
      • VK_IMAGE_ASPECT_STENCIL_BIT

        public static final int VK_IMAGE_ASPECT_STENCIL_BIT
        VkImageAspectFlagBits
        See Also:
        Constant Field Values
      • VK_IMAGE_ASPECT_METADATA_BIT

        public static final int VK_IMAGE_ASPECT_METADATA_BIT
        VkImageAspectFlagBits
        See Also:
        Constant Field Values
      • VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT

        public static final int VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT
        If set, the image uses a single mip tail region for all array layers.
        See Also:
        Constant Field Values
      • VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT

        public static final int VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT
        If set, the first mip level that is not an exact multiple of the sparse image block size begins the mip tail region.
        See Also:
        Constant Field Values
      • VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT

        public static final int VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
        If set, the image uses a non-standard sparse block size, and the imageGranularity values do not match the standard block size for the given pixel format.
        See Also:
        Constant Field Values
      • VK_SPARSE_MEMORY_BIND_METADATA_BIT

        public static final int VK_SPARSE_MEMORY_BIND_METADATA_BIT
        Is used to indicate that the memory being bound is only for the metadata aspect.
        See Also:
        Constant Field Values
      • VK_FENCE_CREATE_SIGNALED_BIT

        public static final int VK_FENCE_CREATE_SIGNALED_BIT
        If set, then the fence object is created in the signaled state. Otherwise it is created in the unsignaled state.
        See Also:
        Constant Field Values
      • VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT

        public static final int VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT
        If set, queries managed by the pool will count the number of vertices processed by the input assembly stage. Vertices corresponding to incomplete primitives may contribute to the count.
        See Also:
        Constant Field Values
      • VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT

        public static final int VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT
        If set, queries managed by the pool will count the number of primitives processed by the input assembly stage. If primitive restart is enabled, restarting the primitive topology has no effect on the count. Incomplete primitives may be counted.
        See Also:
        Constant Field Values
      • VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT

        public static final int VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT
        If set, queries managed by the pool will count the number of vertex shader invocations. This counter’s value is incremented each time a vertex shader is invoked.
        See Also:
        Constant Field Values
      • VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT

        public static final int VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT
        If set, queries managed by the pool will count the number of geometry shader invocations. This counter’s value is incremented each time a geometry shader is invoked. In the case of instanced geometry shaders, the geometry shader invocations count is incremented for each separate instanced invocation.
        See Also:
        Constant Field Values
      • VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT

        public static final int VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT
        If set, queries managed by the pool will count the number of primitives generated by geometry shader invocations. The counter’s value is incremented each time the geometry shader emits a primitive. Restarting primitive topology using the SPIR-V instructions OpEndPrimitive or OpEndStreamPrimitive has no effect on the geometry shader output primitives count.
        See Also:
        Constant Field Values
      • VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT

        public static final int VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT
        If set, queries managed by the pool will count the number of primitives processed by the Primitive Clipping stage of the pipeline. The counter’s value is incremented each time a primitive reaches the primitive clipping stage.
        See Also:
        Constant Field Values
      • VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT

        public static final int VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT
        IF set, queries managed by the pool will count the number of primitives output by the Primitive Clipping stage of the pipeline. The counter’s value is incremented each time a primitive passes the primitive clipping stage. The actual number of primitives output by the primitive clipping stage for a particular input primitive is implementation-dependent but must satisfy the following conditions:
        • If at least one vertex of the input primitive lies inside the clipping volume, the counter is incremented by one or more.
        • Otherwise, the counter is incremented by zero or more.
        See Also:
        Constant Field Values
      • VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT

        public static final int VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT
        IF set, queries managed by the pool will count the number of fragment shader invocations. The counter’s value is incremented each time the fragment shader is invoked.
        See Also:
        Constant Field Values
      • VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT

        public static final int VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT
        If set, queries managed by the pool will count the number of patches processed by the tessellation control shader. The counter’s value is incremented once for each patch for which a tessellation control shader is invoked.
        See Also:
        Constant Field Values
      • VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT

        public static final int VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT
        If set, queries managed by the pool will count the number of invocations of the tessellation evaluation shader. The counter’s value is incremented each time the tessellation evaluation shader is invoked.
        See Also:
        Constant Field Values
      • VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT

        public static final int VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
        If set, queries managed by the pool will count the number of compute shader invocations. The counter’s value is incremented every time the compute shader is invoked. Implementations may skip the execution of certain compute shader invocations or execute additional compute shader invocations for implementation-dependent reasons as long as the results of rendering otherwise remain unchanged.
        See Also:
        Constant Field Values
      • VK_QUERY_RESULT_64_BIT

        public static final int VK_QUERY_RESULT_64_BIT
        Indicates the results will be written as an array of 64-bit unsigned integer values. If this bit is not set, the results will be written as an array of 32-bit unsigned integer values.
        See Also:
        Constant Field Values
      • VK_QUERY_RESULT_WAIT_BIT

        public static final int VK_QUERY_RESULT_WAIT_BIT
        Indicates that Vulkan will wait for each query’s status to become available before retrieving its results.
        See Also:
        Constant Field Values
      • VK_QUERY_RESULT_WITH_AVAILABILITY_BIT

        public static final int VK_QUERY_RESULT_WITH_AVAILABILITY_BIT
        Indicates that the availability status accompanies the results.
        See Also:
        Constant Field Values
      • VK_QUERY_RESULT_PARTIAL_BIT

        public static final int VK_QUERY_RESULT_PARTIAL_BIT
        Indicates that returning partial results is acceptable.
        See Also:
        Constant Field Values
      • VK_BUFFER_CREATE_SPARSE_BINDING_BIT

        public static final int VK_BUFFER_CREATE_SPARSE_BINDING_BIT
        Indicates that the buffer will be backed using sparse memory binding.
        See Also:
        Constant Field Values
      • VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT

        public static final int VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT
        Indicates that the buffer can be partially backed using sparse memory binding. Buffers created with this flag must also be created with the BUFFER_CREATE_SPARSE_BINDING_BIT flag.
        See Also:
        Constant Field Values
      • VK_BUFFER_CREATE_SPARSE_ALIASED_BIT

        public static final int VK_BUFFER_CREATE_SPARSE_ALIASED_BIT
        Iindicates that the buffer will be backed using sparse memory binding with memory ranges that might also simultaneously be backing another buffer (or another portion of the same buffer). Buffers created with this flag must also be created with the BUFFER_CREATE_SPARSE_BINDING_BIT flag.
        See Also:
        Constant Field Values
      • VK_BUFFER_USAGE_TRANSFER_SRC_BIT

        public static final int VK_BUFFER_USAGE_TRANSFER_SRC_BIT
        Indicates that the buffer can be used as the source of a transfer command.
        See Also:
        Constant Field Values
      • VK_BUFFER_USAGE_TRANSFER_DST_BIT

        public static final int VK_BUFFER_USAGE_TRANSFER_DST_BIT
        Indicates that the buffer can be used as the destination of a transfer command.
        See Also:
        Constant Field Values
      • VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT

        public static final int VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
        Indicates that the buffer can be used to create a VkBufferView suitable for occupying a VkDescriptorSet slot of type DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER.
        See Also:
        Constant Field Values
      • VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT

        public static final int VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
        Indicates that the buffer can be used to create a VkBufferView suitable for occupying a VkDescriptorSet slot of type DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER.
        See Also:
        Constant Field Values
      • VK_BUFFER_USAGE_INDEX_BUFFER_BIT

        public static final int VK_BUFFER_USAGE_INDEX_BUFFER_BIT
        Indicates that the buffer is suitable for passing as the buffer parameter to CmdBindIndexBuffer.
        See Also:
        Constant Field Values
      • VK_BUFFER_USAGE_VERTEX_BUFFER_BIT

        public static final int VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
        Indicates that the buffer is suitable for passing as an element of the pBuffers array to CmdBindVertexBuffers.
        See Also:
        Constant Field Values
      • VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT

        public static final int VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT
        Specifies that the created pipeline will not be optimized. Using this flag may reduce the time taken to create the pipeline.
        See Also:
        Constant Field Values
      • VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT

        public static final int VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT
        Specifies that the pipeline to be created is allowed to be the parent of a pipeline that will be created in a subsequent call to CreateGraphicsPipelines.
        See Also:
        Constant Field Values
      • VK_PIPELINE_CREATE_DERIVATIVE_BIT

        public static final int VK_PIPELINE_CREATE_DERIVATIVE_BIT
        Specifies that the pipeline to be created will be a child of a previously created parent pipeline.
        See Also:
        Constant Field Values
      • VK_SHADER_STAGE_VERTEX_BIT

        public static final int VK_SHADER_STAGE_VERTEX_BIT
        VkShaderStageFlagBits
        See Also:
        Constant Field Values
      • VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT

        public static final int VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT
        VkShaderStageFlagBits
        See Also:
        Constant Field Values
      • VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT

        public static final int VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT
        VkShaderStageFlagBits
        See Also:
        Constant Field Values
      • VK_SHADER_STAGE_GEOMETRY_BIT

        public static final int VK_SHADER_STAGE_GEOMETRY_BIT
        VkShaderStageFlagBits
        See Also:
        Constant Field Values
      • VK_SHADER_STAGE_FRAGMENT_BIT

        public static final int VK_SHADER_STAGE_FRAGMENT_BIT
        VkShaderStageFlagBits
        See Also:
        Constant Field Values
      • VK_SHADER_STAGE_COMPUTE_BIT

        public static final int VK_SHADER_STAGE_COMPUTE_BIT
        VkShaderStageFlagBits
        See Also:
        Constant Field Values
      • VK_SHADER_STAGE_ALL_GRAPHICS

        public static final int VK_SHADER_STAGE_ALL_GRAPHICS
        VkShaderStageFlagBits
        See Also:
        Constant Field Values
      • VK_SHADER_STAGE_ALL

        public static final int VK_SHADER_STAGE_ALL
        VkShaderStageFlagBits
        See Also:
        Constant Field Values
      • VK_CULL_MODE_NONE

        public static final int VK_CULL_MODE_NONE
        If set, no triangles are discarded.
        See Also:
        Constant Field Values
      • VK_CULL_MODE_FRONT_BIT

        public static final int VK_CULL_MODE_FRONT_BIT
        If set, front-facing triangles are discarded.
        See Also:
        Constant Field Values
      • VK_CULL_MODE_BACK_BIT

        public static final int VK_CULL_MODE_BACK_BIT
        If set, back-facing triangles are discarded.
        See Also:
        Constant Field Values
      • VK_CULL_MODE_FRONT_AND_BACK

        public static final int VK_CULL_MODE_FRONT_AND_BACK
        If set, all triangles are discarded.
        See Also:
        Constant Field Values
      • VK_COLOR_COMPONENT_R_BIT

        public static final int VK_COLOR_COMPONENT_R_BIT
        If set, then the R value is written to color attachment for the appropriate sample, otherwise the value in memory is unmodified.
        See Also:
        Constant Field Values
      • VK_COLOR_COMPONENT_G_BIT

        public static final int VK_COLOR_COMPONENT_G_BIT
        If set, then the G value is written to color attachment for the appropriate sample, otherwise the value in memory is unmodified.
        See Also:
        Constant Field Values
      • VK_COLOR_COMPONENT_B_BIT

        public static final int VK_COLOR_COMPONENT_B_BIT
        If set, then the B value is written to color attachment for the appropriate sample, otherwise the value in memory is unmodified.
        See Also:
        Constant Field Values
      • VK_COLOR_COMPONENT_A_BIT

        public static final int VK_COLOR_COMPONENT_A_BIT
        If set, then the A value is written to color attachment for the appropriate sample, otherwise the value in memory is unmodified.
        See Also:
        Constant Field Values
      • VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT

        public static final int VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
        If set, then the attachment is treated as if it shares physical memory with another attachment in the same render pass. This information limits the ability of the implementation to reorder certain operations (like layout transitions and the loadOp) such that it is not improperly reordered against other uses of the same physical memory via a different attachment. This is described in more detail below.

        If a render pass uses multiple attachments that alias the same device memory, those attachments must each include the ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT bit in their attachment description flags. Attachments aliasing the same memory occurs in multiple ways:

        • Multiple attachments being assigned the same image view as part of framebuffer creation.
        • Attachments using distinct image views that correspond to the same image subresource of an image.
        • Attachments using views of distinct image subresources which are bound to overlapping memory.

        Render passes must include subpass dependencies (either directly or via a subpass dependency chain) between any two subpasses that operate on the same attachment or aliasing attachments and those subpass dependencies must include execution and memory dependencies separating uses of the aliases, if at least one of those subpasses writes to one of the aliases. Those dependencies must not include the DEPENDENCY_BY_REGION_BIT if the aliases are views of distinct image subresources which overlap in memory.

        Multiple attachments that alias the same memory must not be used in a single subpass. A given attachment index must not be used multiple times in a single subpass, with one exception: two subpass attachments can use the same attachment index if at least one use is as an input attachment and neither use is as a resolve or preserve attachment. In other words, the same view can be used simultaneously as an input and color or depth/stencil attachment, but must not be used as multiple color or depth/stencil attachments nor as resolve or preserve attachments.

        If a set of attachments alias each other, then all except the first to be used in the render pass must use an initialLayout of IMAGE_LAYOUT_UNDEFINED, since the earlier uses of the other aliases make their contents undefined. Once an alias has been used and a different alias has been used after it, the first alias must not be used in any later subpasses. However, an application can assign the same image view to multiple aliasing attachment indices, which allows that image view to be used multiple times even if other aliases are used in between. Once an attachment needs the ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT bit, there should be no additional cost of introducing additional aliases, and using these additional aliases may allow more efficient clearing of the attachments on multiple uses via ATTACHMENT_LOAD_OP_CLEAR.

        Note

        The exact set of attachment indices that alias with each other is not known until a framebuffer is created using the render pass, so the above conditions cannot be validated at render pass creation time.

        See Also:
        Constant Field Values
      • VK_ACCESS_INDIRECT_COMMAND_READ_BIT

        public static final int VK_ACCESS_INDIRECT_COMMAND_READ_BIT
        Indicates that the access is an indirect command structure read as part of an indirect drawing command.
        See Also:
        Constant Field Values
      • VK_ACCESS_INDEX_READ_BIT

        public static final int VK_ACCESS_INDEX_READ_BIT
        Indicates that the access is an index buffer read.
        See Also:
        Constant Field Values
      • VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT

        public static final int VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT
        Indicates that the access is a read via the vertex input bindings.
        See Also:
        Constant Field Values
      • VK_ACCESS_UNIFORM_READ_BIT

        public static final int VK_ACCESS_UNIFORM_READ_BIT
        Indicates that the access is a read via a uniform buffer or dynamic uniform buffer descriptor.
        See Also:
        Constant Field Values
      • VK_ACCESS_INPUT_ATTACHMENT_READ_BIT

        public static final int VK_ACCESS_INPUT_ATTACHMENT_READ_BIT
        Indicates that the access is a read via an input attachment descriptor.
        See Also:
        Constant Field Values
      • VK_ACCESS_SHADER_READ_BIT

        public static final int VK_ACCESS_SHADER_READ_BIT
        Indicates that the access is a read from a shader via any other descriptor type.
        See Also:
        Constant Field Values
      • VK_ACCESS_SHADER_WRITE_BIT

        public static final int VK_ACCESS_SHADER_WRITE_BIT
        Indicates that the access is a write or atomic from a shader via the same descriptor types as in ACCESS_SHADER_READ_BIT.
        See Also:
        Constant Field Values
      • VK_ACCESS_COLOR_ATTACHMENT_READ_BIT

        public static final int VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
        Indicates that the access is a read via a color attachment.
        See Also:
        Constant Field Values
      • VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT

        public static final int VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
        Indicates that the access is a write via a color or resolve attachment.
        See Also:
        Constant Field Values
      • VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT

        public static final int VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT
        Indicates that the access is a read via a depth/stencil attachment.
        See Also:
        Constant Field Values
      • VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT

        public static final int VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
        Indicates that the access is a write via a depth/stencil attachment.
        See Also:
        Constant Field Values
      • VK_ACCESS_TRANSFER_READ_BIT

        public static final int VK_ACCESS_TRANSFER_READ_BIT
        Indicates that the access is a read from a transfer (copy, blit, resolve, etc.) operation. For the complete set of transfer operations, see PIPELINE_STAGE_TRANSFER_BIT.
        See Also:
        Constant Field Values
      • VK_ACCESS_TRANSFER_WRITE_BIT

        public static final int VK_ACCESS_TRANSFER_WRITE_BIT
        Indicates that the access is a write from a transfer (copy, blit, resolve, etc.) operation. For the complete set of transfer operations, see PIPELINE_STAGE_TRANSFER_BIT.
        See Also:
        Constant Field Values
      • VK_ACCESS_HOST_READ_BIT

        public static final int VK_ACCESS_HOST_READ_BIT
        Indicates that the access is a read via the host.
        See Also:
        Constant Field Values
      • VK_ACCESS_HOST_WRITE_BIT

        public static final int VK_ACCESS_HOST_WRITE_BIT
        Indicates that the access is a write via the host.
        See Also:
        Constant Field Values
      • VK_ACCESS_MEMORY_READ_BIT

        public static final int VK_ACCESS_MEMORY_READ_BIT
        Indicates that the access is a read via a non-specific unit attached to the memory. This unit may be external to the Vulkan device or otherwise not part of the core Vulkan pipeline. When included in dstAccessMask, all writes using access types in srcAccessMask performed by pipeline stages in srcStageMask must be visible in memory.
        See Also:
        Constant Field Values
      • VK_ACCESS_MEMORY_WRITE_BIT

        public static final int VK_ACCESS_MEMORY_WRITE_BIT
        Indicates that the access is a write via a non-specific unit attached to the memory. This unit may be external to the Vulkan device or otherwise not part of the core Vulkan pipeline. When included in srcAccessMask, all access types in dstAccessMask from pipeline stages in dstStageMask will observe the side effects of commands that executed before the barrier. When included in dstAccessMask all writes using access types in srcAccessMask performed by pipeline stages in srcStageMask must be visible in memory.
        See Also:
        Constant Field Values
      • VK_DEPENDENCY_BY_REGION_BIT

        public static final int VK_DEPENDENCY_BY_REGION_BIT
        If set, then the dependency is by-region.
        See Also:
        Constant Field Values
      • VK_COMMAND_POOL_CREATE_TRANSIENT_BIT

        public static final int VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
        Indicates that command buffers allocated from the pool will be short-lived, meaning that they will be reset or freed in a relatively short timeframe. This flag may be used by the implementation to control memory allocation behavior within the pool.
        See Also:
        Constant Field Values
      • VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT

        public static final int VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
        Controls whether command buffers allocated from the pool can be individually reset. If this flag is set, individual command buffers allocated from the pool can be reset either explicitly, by calling ResetCommandBuffer, or implicitly, by calling BeginCommandBuffer on an executable command buffer. If this flag is not set, then ResetCommandBuffer and BeginCommandBuffer (on an executable command buffer) must not be called on the command buffers allocated from the pool, and they can only be reset in bulk by calling ResetCommandPool.
        See Also:
        Constant Field Values
      • VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT

        public static final int VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
        If set, resetting a command pool recycles all of the resources from the command pool back to the system.
        See Also:
        Constant Field Values
      • VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT

        public static final int VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
        Indicates that each recording of the command buffer will only be submitted once, and the command buffer will be reset and recorded again between each submission.
        See Also:
        Constant Field Values
      • VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT

        public static final int VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
        Indicates that a secondary command buffer is considered to be entirely inside a render pass. If this is a primary command buffer, then this bit is ignored.
        See Also:
        Constant Field Values
      • VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT

        public static final int VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
        Allows the command buffer to be resubmitted to a queue or recorded into a primary command buffer while it is pending execution.
        See Also:
        Constant Field Values
      • VK_QUERY_CONTROL_PRECISE_BIT

        public static final int VK_QUERY_CONTROL_PRECISE_BIT
        If set, an implementation must return a result that matches the actual number of samples passed.
        See Also:
        Constant Field Values
      • VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT

        public static final int VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
        If set, then most or all memory resources currently owned by the command buffer should be returned to the parent command pool. If this flag is not set, then the command buffer may hold onto memory resources and reuse them when recording commands.
        See Also:
        Constant Field Values
      • VK_STENCIL_FACE_FRONT_BIT

        public static final int VK_STENCIL_FACE_FRONT_BIT
        Indicates that only the front set of stencil state is updated.
        See Also:
        Constant Field Values
      • VK_STENCIL_FACE_BACK_BIT

        public static final int VK_STENCIL_FACE_BACK_BIT
        Indicates that only the back set of stencil state is updated.
        See Also:
        Constant Field Values
    • Method Detail

      • vkCreateInstance

        public static int vkCreateInstance(VkInstanceCreateInfo pCreateInfo,
                                           VkAllocationCallbacks pAllocator,
                                           PointerBuffer pInstance)

        Khronos Reference Page

        Creates a new Vulkan instance.

        There is no global state in Vulkan and all per-application state is stored in a VkInstance object. Creating a VkInstance object initializes the Vulkan library and allows the application to pass information about itself to the implementation.

        vkCreateInstance creates the instance, then enables and initializes global layers and extensions requested by the application. If an extension is provided by a layer, both the layer and extension must be specified at vkCreateInstance time.

        Valid Usage
        • pCreateInfo must be a pointer to a valid VkInstanceCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pInstance must be a pointer to a VkInstance handle
        Parameters:
        pCreateInfo - points to an instance of VkInstanceCreateInfo controlling creation of the instance
        pAllocator - controls host memory allocation
        pInstance - a pointer to a VkInstance handle in which the resulting instance is returned
      • vkDestroyInstance

        public static void vkDestroyInstance(VkInstance instance,
                                             VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys an instance of Vulkan.

        After destruction of the instance, all devices (logical and physical) and any objects created by those devices become invalid and should not be accessed. However, objects allocated directly or indirectly through the instance are not destroyed automatically and so may be leaked. Applications should destroy all objects created through instance before destroying the instance itself.

        Valid Usage
        • If instance is not NULL, instance must be a valid VkInstance handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • All child objects created using instance must have been destroyed prior to destroying instance
        • If VkAllocationCallbacks were provided when instance was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when instance was created, pAllocator must be NULL
        Host Synchronization
        • Host access to instance must be externally synchronized
        Parameters:
        instance - the handle of the instance to destroy
        pAllocator - controls host memory allocation
      • vkEnumeratePhysicalDevices

        public static int vkEnumeratePhysicalDevices(VkInstance instance,
                                                     java.nio.IntBuffer pPhysicalDeviceCount,
                                                     PointerBuffer pPhysicalDevices)

        Khronos Reference Page

        Retrieves a list of physical device objects representing the physical devices installed in the system.

        If pPhysicalDevices is NULL, then the number of physical devices available is returned in pPhysicalDeviceCount. Otherwise, pPhysicalDeviceCount must point to a variable set by the user to the number of elements in the pPhysicalDevices array, and on return the variable is overwritten with the number of structures actually written to pPhysicalDevices. If pPhysicalDeviceCount is less than the number of physical devices available, at most pPhysicalDeviceCount structures will be written. If pPhysicalDeviceCount is smaller than the number of physical devices available, INCOMPLETE will be returned instead of SUCCESS, to indicate that not all the available physical devices were returned.

        Once enumerated, general properties of the physical devices are queried by calling GetPhysicalDeviceProperties.

        Valid Usage
        • instance must be a valid VkInstance handle
        • pPhysicalDeviceCount must be a pointer to a uint32_t value
        • If the value referenced by pPhysicalDeviceCount is not 0, and pPhysicalDevices is not NULL, pPhysicalDevices must be a pointer to an array of pPhysicalDeviceCount VkPhysicalDevice handles
        Parameters:
        instance - a handle to a Vulkan instance previously created with CreateInstance
        pPhysicalDeviceCount - a pointer to an integer related to the number of physical devices available or queried
        pPhysicalDevices - either NULL or a pointer to an array of VkPhysicalDevice handles
      • vkGetPhysicalDeviceFeatures

        public static void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
                                                       VkPhysicalDeviceFeatures pFeatures)

        Khronos Reference Page

        Reports capabilities of a physical device.
        Valid Usage
        • physicalDevice must be a valid VkPhysicalDevice handle
        • pFeatures must be a pointer to a VkPhysicalDeviceFeatures structure
        Parameters:
        physicalDevice - the handle to the physical device whose properties will be queried
        pFeatures - points to an instance of the VkPhysicalDeviceProperties structure, that will be filled with returned information
      • vkGetPhysicalDeviceFormatProperties

        public static void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
                                                               int format,
                                                               VkFormatProperties pFormatProperties)

        Khronos Reference Page

        Lists physical device’s format capabilities.
        Valid Usage
        • physicalDevice must be a valid VkPhysicalDevice handle
        • format must be a valid VkFormat value
        • pFormatProperties must be a pointer to a VkFormatProperties structure
        Parameters:
        physicalDevice - the physical device from which to query the format properties
        format - the format whose properties are queried
        pFormatProperties - a pointer to a VkFormatProperties structure in which physical device properties for format are returned
      • vkGetPhysicalDeviceProperties

        public static void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
                                                         VkPhysicalDeviceProperties pProperties)

        Khronos Reference Page

        Returns properties of a physical device.
        Valid Usage
        Parameters:
        physicalDevice - the handle to the physical device whose properties will be queried
        pProperties - points to an instance of the VkPhysicalDeviceProperties structure, that will be filled with returned information
      • vkGetPhysicalDeviceQueueFamilyProperties

        public static void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
                                                                    java.nio.IntBuffer pQueueFamilyPropertyCount,
                                                                    VkQueueFamilyProperties.Buffer pQueueFamilyProperties)

        Khronos Reference Page

        Reports properties of the queues of the specified physical device.

        If pQueueFamilyProperties is NULL, then the number of queue families available is returned in pQueueFamilyPropertyCount. Otherwise, pQueueFamilyPropertyCount must point to a variable set by the user to the number of elements in the pQueueFamilyProperties array, and on return the variable is overwritten with the number of structures actually written to pQueueFamilyProperties. If the value of pQueueFamilyPropertyCount is less than the number of queue families available, at most pQueueFamilyPropertyCount structures will be written.

        Valid Usage
        • physicalDevice must be a valid VkPhysicalDevice handle
        • pQueueFamilyPropertyCount must be a pointer to a uint32_t value
        • If the value referenced by pQueueFamilyPropertyCount is not 0, and pQueueFamilyProperties is not NULL, pQueueFamilyProperties must be a pointer to an array of pQueueFamilyPropertyCount VkQueueFamilyProperties structures
        Parameters:
        physicalDevice - the handle to the physical device whose properties will be queried
        pQueueFamilyPropertyCount - a pointer to an integer related to the number of queue families available or queried
        pQueueFamilyProperties - either NULL or a pointer to an array of VkQueueFamilyProperties structures
      • vkGetInstanceProcAddr

        public static long vkGetInstanceProcAddr(VkInstance instance,
                                                 java.nio.ByteBuffer pName)

        Khronos Reference Page

        Returns a function pointer for a command.
        Valid Usage
        LWJGL Note

        LWJGL requires a non-NULL instance argument when calling this method. If NULL must be used, do the following:

        long GetInstanceProcAddr = VK.getFunctionProvider().getFunctionAddress("vkGetInstanceProcAddr");
        long command = JNI.callPPP(GetInstanceProcAddr, NULL, pName);
        Parameters:
        instance - the instance that the function pointer will be compatible with
        pName - the name of the command to obtain
      • vkGetInstanceProcAddr

        public static long vkGetInstanceProcAddr(VkInstance instance,
                                                 java.lang.CharSequence pName)

        Khronos Reference Page

        Returns a function pointer for a command.
        Valid Usage
        LWJGL Note

        LWJGL requires a non-NULL instance argument when calling this method. If NULL must be used, do the following:

        long GetInstanceProcAddr = VK.getFunctionProvider().getFunctionAddress("vkGetInstanceProcAddr");
        long command = JNI.callPPP(GetInstanceProcAddr, NULL, pName);
        Parameters:
        instance - the instance that the function pointer will be compatible with
        pName - the name of the command to obtain
      • vkGetDeviceProcAddr

        public static long vkGetDeviceProcAddr(VkDevice device,
                                               java.nio.ByteBuffer pName)

        Khronos Reference Page

        Returns a device-specific function pointer for a command.

        In order to support systems with multiple Vulkan implementations comprising heterogeneous collections of hardware and software, the function pointers returned by GetInstanceProcAddr may point to dispatch code, which calls a different real implementation for different VkDevice objects (and objects created from them). The overhead of this internal dispatch can be avoided by obtaining device-specific function pointers for any commands that use a device or device-child object as their dispatchable object.

        Valid Usage
        • device must be a valid VkDevice handle
        • pName must be a null-terminated string
        • pName must be the name of a supported command that has a first parameter of type VkDevice, VkQueue or VkCommandBuffer, either in the core API or an enabled extension
        LWJGL Note

        The function pointers used by LWJGL for commands that have a first parameter of type VkDevice, VkQueue or VkCommandBuffer, have been acquired using this command.

        Parameters:
        device - the logical device that provides the function pointer
        pName - the name of any Vulkan command whose first parameter is one of

        If pName is not the name of one of these Vulkan commands, and is not the name of an extension command belonging to an extension enabled for device, then vkGetDeviceProcAddr will return NULL.

      • vkGetDeviceProcAddr

        public static long vkGetDeviceProcAddr(VkDevice device,
                                               java.lang.CharSequence pName)

        Khronos Reference Page

        Returns a device-specific function pointer for a command.

        In order to support systems with multiple Vulkan implementations comprising heterogeneous collections of hardware and software, the function pointers returned by GetInstanceProcAddr may point to dispatch code, which calls a different real implementation for different VkDevice objects (and objects created from them). The overhead of this internal dispatch can be avoided by obtaining device-specific function pointers for any commands that use a device or device-child object as their dispatchable object.

        Valid Usage
        • device must be a valid VkDevice handle
        • pName must be a null-terminated string
        • pName must be the name of a supported command that has a first parameter of type VkDevice, VkQueue or VkCommandBuffer, either in the core API or an enabled extension
        LWJGL Note

        The function pointers used by LWJGL for commands that have a first parameter of type VkDevice, VkQueue or VkCommandBuffer, have been acquired using this command.

        Parameters:
        device - the logical device that provides the function pointer
        pName - the name of any Vulkan command whose first parameter is one of

        If pName is not the name of one of these Vulkan commands, and is not the name of an extension command belonging to an extension enabled for device, then vkGetDeviceProcAddr will return NULL.

      • vkCreateDevice

        public static int vkCreateDevice(VkPhysicalDevice physicalDevice,
                                         VkDeviceCreateInfo pCreateInfo,
                                         VkAllocationCallbacks pAllocator,
                                         PointerBuffer pDevice)

        Khronos Reference Page

        Creates a new logical device instance.
        Valid Usage
        • physicalDevice must be a valid VkPhysicalDevice handle
        • pCreateInfo must be a pointer to a valid VkDeviceCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pDevice must be a pointer to a VkDevice handle
        Parameters:
        physicalDevice - must be one of the device handles returned from a call to EnumeratePhysicalDevices
        pCreateInfo - a pointer to a VkDeviceCreateInfo structure containing information about how to create the device
        pAllocator - controls host memory allocation
        pDevice - points to a handle in which the created VkDevice is returned
      • vkDestroyDevice

        public static void vkDestroyDevice(VkDevice device,
                                           VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a logical device.

        To ensure that no work is active on the device, DeviceWaitIdle can be used to gate the destruction of the device. Prior to destroying a device, an application is responsible for destroying/freeing any Vulkan objects that were created using that device as the first parameter of the corresponding vkCreate* or vkAllocate* command.

        Note

        The lifetime of each of these objects is bound by the lifetime of the VkDevice object. Therefore, to avoid resource leaks, it is critical that an application explicitly free all of these resources prior to calling vkDestroyDevice.

        Valid Usage
        • If device is not NULL, device must be a valid VkDevice handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • All child objects created on device must have been destroyed prior to destroying device
        • If VkAllocationCallbacks were provided when device was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when device was created, pAllocator must be NULL
        Host Synchronization
        • Host access to device must be externally synchronized
        Parameters:
        device - the logical device to destroy
        pAllocator - controls host memory allocation
      • vkEnumerateInstanceExtensionProperties

        public static int vkEnumerateInstanceExtensionProperties(java.nio.ByteBuffer pLayerName,
                                                                 java.nio.IntBuffer pPropertyCount,
                                                                 VkExtensionProperties.Buffer pProperties)

        Khronos Reference Page

        Queries the available instance extensions.

        Extensions may define new Vulkan commands, structures, and enumerants. For compilation purposes, the interfaces defined by registered extensions, including new structures and enumerants as well as function pointer types for new commands, are defined in the Khronos-supplied vulkan.h together with the core API. However, commands defined by extensions may not be available for static linking - in which case function pointers to these commands should be queried at runtime. Extensions may be provided by layers as well as by a Vulkan implementation.

        If pProperties is NULL, then the number of extensions properties available is returned in pPropertyCount. Otherwise, pPropertyCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of structures actually written to pProperties. If the value of pPropertyCount is less than the number of extension properties available, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of extensions available, INCOMPLETE will be returned instead of SUCCESS, to indicate that not all the available properties were returned.

        Valid Usage
        • If pLayerName is not NULL, pLayerName must be a null-terminated string
        • pPropertyCount must be a pointer to a uint32_t value
        • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkExtensionProperties structures
        • If pLayerName is not NULL, it must be the name of a layer returned by EnumerateInstanceLayerProperties

        When pLayerName parameter is NULL, only extensions provided by the Vulkan implementation or by implicitly enabled layers are returned. When pLayerName is the name of a layer, the instance extensions provided by that layer are returned.

        To enable an instance extension, the name of the extension should be added to the ppEnabledExtensionNames member of VkInstanceCreateInfo when creating a VkInstance.

        Parameters:
        pLayerName - either NULL or a pointer to a null-terminated UTF-8 string naming the layer to retrieve extensions from
        pPropertyCount - a pointer to an integer related to the number of extension properties available or queried
        pProperties - either NULL or a pointer to an array of VkExtensionProperties structures
      • vkEnumerateInstanceExtensionProperties

        public static int vkEnumerateInstanceExtensionProperties(java.lang.CharSequence pLayerName,
                                                                 java.nio.IntBuffer pPropertyCount,
                                                                 VkExtensionProperties.Buffer pProperties)

        Khronos Reference Page

        Queries the available instance extensions.

        Extensions may define new Vulkan commands, structures, and enumerants. For compilation purposes, the interfaces defined by registered extensions, including new structures and enumerants as well as function pointer types for new commands, are defined in the Khronos-supplied vulkan.h together with the core API. However, commands defined by extensions may not be available for static linking - in which case function pointers to these commands should be queried at runtime. Extensions may be provided by layers as well as by a Vulkan implementation.

        If pProperties is NULL, then the number of extensions properties available is returned in pPropertyCount. Otherwise, pPropertyCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of structures actually written to pProperties. If the value of pPropertyCount is less than the number of extension properties available, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of extensions available, INCOMPLETE will be returned instead of SUCCESS, to indicate that not all the available properties were returned.

        Valid Usage
        • If pLayerName is not NULL, pLayerName must be a null-terminated string
        • pPropertyCount must be a pointer to a uint32_t value
        • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkExtensionProperties structures
        • If pLayerName is not NULL, it must be the name of a layer returned by EnumerateInstanceLayerProperties

        When pLayerName parameter is NULL, only extensions provided by the Vulkan implementation or by implicitly enabled layers are returned. When pLayerName is the name of a layer, the instance extensions provided by that layer are returned.

        To enable an instance extension, the name of the extension should be added to the ppEnabledExtensionNames member of VkInstanceCreateInfo when creating a VkInstance.

        Parameters:
        pLayerName - either NULL or a pointer to a null-terminated UTF-8 string naming the layer to retrieve extensions from
        pPropertyCount - a pointer to an integer related to the number of extension properties available or queried
        pProperties - either NULL or a pointer to an array of VkExtensionProperties structures
      • vkEnumerateDeviceExtensionProperties

        public static int vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
                                                               java.nio.ByteBuffer pLayerName,
                                                               java.nio.IntBuffer pPropertyCount,
                                                               VkExtensionProperties.Buffer pProperties)

        Khronos Reference Page

        Queries the extensions available to a given physical device.

        If pProperties is NULL, then the number of extensions properties available is returned in pPropertyCount. Otherwise, pPropertyCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of structures actually written to pProperties. If pPropertyCount is less than the number of extension properties available, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of extensions available, INCOMPLETE will be returned instead of SUCCESS, to indicate that not all the available properties were returned.

        Valid Usage
        • physicalDevice must be a valid VkPhysicalDevice handle
        • If pLayerName is not NULL, pLayerName must be a null-terminated string
        • pPropertyCount must be a pointer to a uint32_t value
        • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkExtensionProperties structures
        • If pLayerName is not NULL, it must be the name of a layer returned by EnumerateDeviceLayerProperties

        When pLayerName parameter is NULL, only extensions provided by the Vulkan implementation or by implicitly enabled layers are returned. When pLayerName is the name of a layer, the device extensions provided by that layer are returned.

        To enable a device layer, the name of the layer should be added to the ppEnabledExtensionNames member of VkDeviceCreateInfo when creating a VkDevice.

        Parameters:
        physicalDevice - the physical device that will be queried
        pLayerName - either NULL or a pointer to a null-terminated UTF-8 string naming the layer to retrieve extensions from
        pPropertyCount - a pointer to an integer related to the number of extension properties available or queried
        pProperties - either NULL or a pointer to an array of VkExtensionProperties structures
      • vkEnumerateDeviceExtensionProperties

        public static int vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
                                                               java.lang.CharSequence pLayerName,
                                                               java.nio.IntBuffer pPropertyCount,
                                                               VkExtensionProperties.Buffer pProperties)

        Khronos Reference Page

        Queries the extensions available to a given physical device.

        If pProperties is NULL, then the number of extensions properties available is returned in pPropertyCount. Otherwise, pPropertyCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of structures actually written to pProperties. If pPropertyCount is less than the number of extension properties available, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of extensions available, INCOMPLETE will be returned instead of SUCCESS, to indicate that not all the available properties were returned.

        Valid Usage
        • physicalDevice must be a valid VkPhysicalDevice handle
        • If pLayerName is not NULL, pLayerName must be a null-terminated string
        • pPropertyCount must be a pointer to a uint32_t value
        • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkExtensionProperties structures
        • If pLayerName is not NULL, it must be the name of a layer returned by EnumerateDeviceLayerProperties

        When pLayerName parameter is NULL, only extensions provided by the Vulkan implementation or by implicitly enabled layers are returned. When pLayerName is the name of a layer, the device extensions provided by that layer are returned.

        To enable a device layer, the name of the layer should be added to the ppEnabledExtensionNames member of VkDeviceCreateInfo when creating a VkDevice.

        Parameters:
        physicalDevice - the physical device that will be queried
        pLayerName - either NULL or a pointer to a null-terminated UTF-8 string naming the layer to retrieve extensions from
        pPropertyCount - a pointer to an integer related to the number of extension properties available or queried
        pProperties - either NULL or a pointer to an array of VkExtensionProperties structures
      • vkEnumerateInstanceLayerProperties

        public static int vkEnumerateInstanceLayerProperties(java.nio.IntBuffer pPropertyCount,
                                                             VkLayerProperties.Buffer pProperties)

        Khronos Reference Page

        Queries the available instance layers.

        If pProperties is NULL, then the number of layer properties available is returned in pPropertyCount. Otherwise, pPropertyCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of structures actually written to pProperties. If pPropertyCount is less than the number of layer properties available, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of layers available, INCOMPLETE will be returned instead of SUCCESS, to indicate that not all the available layer properties were returned.

        Valid Usage
        • pPropertyCount must be a pointer to a uint32_t value
        • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkLayerProperties structures

        To enable an instance layer, the name of the layer should be added to the ppEnabledLayerNames member of VkInstanceCreateInfo when creating a VkInstance.

        When a layer is enabled, it inserts itself into the call chain for Vulkan commands the layer is interested in. A common use of layers is to validate application behavior during development. For example, the implementation will not check that Vulkan enums used by the application fall within allowed ranges. Instead, a validation layer would do those checks and flag issues. This avoids a performance penalty during production use of the application because those layers would not be enabled in production.

        Parameters:
        pPropertyCount - a pointer to an integer related to the number of layer properties available or queried
        pProperties - either NULL or a pointer to an array of VkLayerProperties structures
      • vkEnumerateDeviceLayerProperties

        public static int vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
                                                           java.nio.IntBuffer pPropertyCount,
                                                           VkLayerProperties.Buffer pProperties)

        Khronos Reference Page

        Queries the available device layers.

        If pProperties is NULL, then the number of layer properties available is returned in pPropertyCount. Otherwise, pPropertyCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of structures actually written to pProperties. If the value of pPropertyCount is less than the number of layer properties available, at most pPropertyCount structures will be written. If pPropertyCount is smaller than the number of layers available, INCOMPLETE will be returned instead of SUCCESS, to indicate that not all the available layer properties were returned.

        Valid Usage
        • physicalDevice must be a valid VkPhysicalDevice handle
        • pPropertyCount must be a pointer to a uint32_t value
        • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkLayerProperties structures

        To enable a device layer, the name of the layer should be added to the ppEnabledLayerNames member of VkDeviceCreateInfo when creating a VkDevice.

        Loader implementations may provide mechanisms outside the Vulkan API for enabling specific layers. Layers enabled through such a mechanism are implicitly enabled, while layers enabled by including the layer name in the ppEnabledLayerNames member of VkDeviceCreateInfo are explicitly enabled. Except where otherwise specified, implicitly enabled and explicitly enabled layers differ only in the way they are enabled. Explicitly enabling a layer that is implicitly enabled has no additional effect.

        Parameters:
        physicalDevice - the physical device that will be queried
        pPropertyCount - a pointer to an integer related to the number of layer properties available or queried
        pProperties - either NULL or a pointer to an array of VkLayerProperties structures
      • vkGetDeviceQueue

        public static void vkGetDeviceQueue(VkDevice device,
                                            int queueFamilyIndex,
                                            int queueIndex,
                                            PointerBuffer pQueue)

        Khronos Reference Page

        Retrieves a handle to a VkQueue object.

        The queue family index is used in multiple places in Vulkan in order to tie operations to a specific family of queues.

        When retrieving a handle to the queue via vkGetDeviceQueue, the queue family index is used to select which queue family to retrieve the VkQueue handle from.

        When creating a VkCommandPool object (see Command Pools), a queue family index is specified in the VkCommandPoolCreateInfo structure. Command buffers from this pool can only be submitted on queues corresponding to this queue family.

        When creating VkImage and VkBuffer resources, a set of queue families is included in the VkImageCreateInfo and VkBufferCreateInfo structures to specify the queue families that can access the resource.

        When inserting a VkBufferMemoryBarrier or VkImageMemoryBarrier a source and destination queue family index is specified to allow the ownership of a buffer or image to be transferred from one queue family to another.

        Each queue is assigned a priority, as set in the VkDeviceQueueCreateInfo structures when creating the device. The priority of each queue is a normalized floating point value between 0.0 and 1.0, which is then translated to a discrete priority level by the implementation. Higher values indicate a higher priority, with 0.0 being the lowest priority and 1.0 being the highest.

        Within the same device, queues with higher priority may be allotted more processing time than queues with lower priority. The implementation makes no guarantees with regards to ordering or scheduling among queues with the same priority, other than the constraints defined by explicit scheduling primitives. The implementation make no guarantees with regards to queues across different devices.

        An implementation may allow a higher-priority queue to starve a lower-priority queue on the same VkDevice until the higher-priority queue has no further commands to execute. The relationship of queue priorities must not cause queues on one VkDevice to starve queues on another VkDevice.

        No specific guarantees are made about higher priority queues receiving more processing time or better quality of service than lower priority queues.

        Valid Usage
        • device must be a valid VkDevice handle
        • pQueue must be a pointer to a VkQueue handle
        • queueFamilyIndex must be one of the queue family indices specified when device was created, via the VkDeviceQueueCreateInfo structure
        • queueIndex must be less than the number of queues created for the specified queue family index when device was created, via the queueCount member of the VkDeviceQueueCreateInfo structure
        Parameters:
        device - the logical device that owns the queue
        queueFamilyIndex - the index of the queue family to which the queue belongs
        queueIndex - the index within this queue family of the queue to retrieve
        pQueue - a pointer to a VkQueue object that will be filled with the handle for the requested queue
      • vkQueueSubmit

        public static int vkQueueSubmit(VkQueue queue,
                                        VkSubmitInfo.Buffer pSubmits,
                                        long fence)

        Khronos Reference Page

        Submits a sequence of semaphores or command buffers to a queue.

        Each call to vkQueueSubmit submits zero or more batches of work to the queue for execution. submitCount is used to specify the number of batches to submit. Each batch includes zero or more semaphores to wait upon, and a corresponding set of stages that will wait for the semaphore to be signaled before executing any work, followed by a number of command buffers that will be executed, and finally, zero or more semaphores that will be signaled after command buffer execution completes. Each batch is represented as an instance of the VkSubmitInfo structure stored in an array, the address of which is passed in pSubmits.

        Note

        The exact definition of a submission is platform-specific, but is considered a relatively expensive operation. In general, applications should attempt to batch work together into as few calls to vkQueueSubmit as possible.

        Valid Usage
        • queue must be a valid VkQueue handle
        • If submitCount is not 0, pSubmits must be a pointer to an array of submitCount valid VkSubmitInfo structures
        • If fence is not NULL_HANDLE, fence must be a valid VkFence handle
        • Each of queue and fence that are valid handles must have been created, allocated or retrieved from the same VkDevice
        • If fence is not NULL_HANDLE, fence must be unsignaled
        • If fence is not NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue
        Host Synchronization
        • Host access to queue must be externally synchronized
        • Host access to pSubmits[].pWaitSemaphores[] must be externally synchronized
        • Host access to pSubmits[].pSignalSemaphores[] must be externally synchronized
        • Host access to fence must be externally synchronized
        Parameters:
        queue - the handle of the queue that the command buffers will be submitted to
        pSubmits - a pointer to an array of VkSubmitInfo structures which describe the work to submit. All work described by pSubmits must be submitted to the queue before the command returns.
        fence - an optional handle to a fence. If fence is not NULL_HANDLE, the fence is signaled when execution of all command buffers specified in the VkSubmitInfo::pCommandBuffers members of pSubmits is complete, providing certain implicit ordering guarantees. If submitCount is zero but fence is not NULL_HANDLE, the fence will still be submitted to the queue and will become signaled when all work previously submitted to the queue has completed.
      • vkQueueSubmit

        public static int vkQueueSubmit(VkQueue queue,
                                        VkSubmitInfo pSubmit,
                                        long fence)

        Khronos Reference Page

        Submits a sequence of semaphores or command buffers to a queue.

        Each call to vkQueueSubmit submits zero or more batches of work to the queue for execution. submitCount is used to specify the number of batches to submit. Each batch includes zero or more semaphores to wait upon, and a corresponding set of stages that will wait for the semaphore to be signaled before executing any work, followed by a number of command buffers that will be executed, and finally, zero or more semaphores that will be signaled after command buffer execution completes. Each batch is represented as an instance of the VkSubmitInfo structure stored in an array, the address of which is passed in pSubmits.

        Note

        The exact definition of a submission is platform-specific, but is considered a relatively expensive operation. In general, applications should attempt to batch work together into as few calls to vkQueueSubmit as possible.

        Valid Usage
        • queue must be a valid VkQueue handle
        • If submitCount is not 0, pSubmits must be a pointer to an array of submitCount valid VkSubmitInfo structures
        • If fence is not NULL_HANDLE, fence must be a valid VkFence handle
        • Each of queue and fence that are valid handles must have been created, allocated or retrieved from the same VkDevice
        • If fence is not NULL_HANDLE, fence must be unsignaled
        • If fence is not NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue
        Host Synchronization
        • Host access to queue must be externally synchronized
        • Host access to pSubmits[].pWaitSemaphores[] must be externally synchronized
        • Host access to pSubmits[].pSignalSemaphores[] must be externally synchronized
        • Host access to fence must be externally synchronized
        Parameters:
        queue - the handle of the queue that the command buffers will be submitted to
        fence - an optional handle to a fence. If fence is not NULL_HANDLE, the fence is signaled when execution of all command buffers specified in the VkSubmitInfo::pCommandBuffers members of pSubmits is complete, providing certain implicit ordering guarantees. If submitCount is zero but fence is not NULL_HANDLE, the fence will still be submitted to the queue and will become signaled when all work previously submitted to the queue has completed.
      • vkQueueWaitIdle

        public static int vkQueueWaitIdle(VkQueue queue)

        Khronos Reference Page

        Waits on the completion of all work within a single queue.

        vkQueueWaitIdle will block until all command buffers and sparse binding operations in the queue have completed.

        Valid Usage
        • queue must be a valid VkQueue handle
        Parameters:
        queue - the queue on which to wait
      • vkDeviceWaitIdle

        public static int vkDeviceWaitIdle(VkDevice device)

        Khronos Reference Page

        Waits for a device to become idle.

        A device is active while any of its queues have work to process. Once all device queues are idle, the device is idle.

        Valid Usage
        • device must be a valid VkDevice handle
        Host Synchronization
        • Host access to all VkQueue objects created from device must be externally synchronized
        Parameters:
        device - the logical device to idle
      • vkAllocateMemory

        public static int vkAllocateMemory(VkDevice device,
                                           VkMemoryAllocateInfo pAllocateInfo,
                                           VkAllocationCallbacks pAllocator,
                                           java.nio.LongBuffer pMemory)

        Khronos Reference Page

        Allocates device memory.

        Allocations returned by vkAllocateMemory are guaranteed to meet any alignment requirement by the implementation. For example, if an implementation requires 128 byte alignment for images and 64 byte alignment for buffers, the device memory returned through this mechanism would be 128-byte aligned. This ensures that applications can correctly suballocate objects of different types (with potentially different alignment requirements) in the same memory object.

        When memory is allocated, its contents are undefined.

        There is an implementation-dependent maximum number of memory allocations which can be simultaneously created on a device. This is specified by the maxMemoryAllocationCount member of the VkPhysicalDeviceLimits structure. If maxMemoryAllocationCount is exceeded, vkAllocateMemory will return ERROR_TOO_MANY_OBJECTS.

        Note

        Some platforms may have a limit on the maximum size of a single allocation. For example, certain systems may fail to create allocations with a size greater than or equal to 4GB. Such a limit is implementation-dependent, and if such a failure occurs then the error ERROR_OUT_OF_DEVICE_MEMORY should be returned.

        Valid Usage
        • device must be a valid VkDevice handle
        • pAllocateInfo must be a pointer to a valid VkMemoryAllocateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pMemory must be a pointer to a VkDeviceMemory handle
        • The number of currently valid memory objects, allocated from device, must be less than VkPhysicalDeviceLimits::maxMemoryAllocationCount
        Parameters:
        device - the logical device that owns the memory
        pAllocateInfo - a pointer to an instance of the VkMemoryAllocateInfo structure describing parameters of the allocation. A successful returned allocation must use the requested parameters -- no substitution is permitted by the implementation.
        pAllocator - controls host memory allocation
        pMemory - a pointer to a VkDeviceMemory handle in which information about the allocated memory is returned
      • vkFreeMemory

        public static void vkFreeMemory(VkDevice device,
                                        long memory,
                                        VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Frees a memory object.

        Before freeing a memory object, an application must ensure the memory object is no longer in use by the device — for example by command buffers queued for execution. The memory can remain bound to images or buffers at the time the memory object is freed, but any further use of them (on host or device) for anything other than destroying those objects will result in undefined behavior. If there are still any bound images or buffers, the memory may not be immediately released by the implementation, but must be released by the time all bound images and buffers have been destroyed. Once memory is released, it is returned to the heap from which it was allocated.

        If a memory object is mapped at the time it is freed, it is implicitly unmapped.

        Valid Usage
        • device must be a valid VkDevice handle
        • If memory is not NULL_HANDLE, memory must be a valid VkDeviceMemory handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If memory is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and memory that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to memory (via images or buffers) must have completed execution
        Host Synchronization
        • Host access to memory must be externally synchronized
        Parameters:
        device - the logical device that owns the memory
        memory - the VkDeviceMemory object to be freed
        pAllocator - controls host memory allocation
      • vkMapMemory

        public static int vkMapMemory(VkDevice device,
                                      long memory,
                                      long offset,
                                      long size,
                                      int flags,
                                      PointerBuffer ppData)

        Khronos Reference Page

        Retrieves a host virtual address pointer to a region of a mappable memory object.

        Memory objects created with AllocateMemory are not directly host accessible. Memory objects created with the memory property MEMORY_PROPERTY_HOST_VISIBLE_BIT are considered mappable. Memory objects must be mappable in order to be successfully mapped on the host.

        It is an application error to call vkMapMemory on a memory object that is already mapped.

        vkMapMemory does not check whether the device memory is currently in use before returning the host-accessible pointer. The application must guarantee that any previously submitted command that writes to this range has completed before the host reads from or writes to that range, and that any previously submitted command that reads from that range has completed before the host writes to that region. If the device memory was allocated without the MEMORY_PROPERTY_HOST_COHERENT_BIT set, these guarantees must be made for an extended range: the application must round down the start of the range to the nearest multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize, and round the end of the range up to the nearest multiple of VkPhysicalDeviceLimits::nonCoherentAtomSize.

        While a range of device memory is mapped for host access, the application is responsible for synchronizing both device and host access to that memory range.

        Host-visible memory types that advertise the MEMORY_PROPERTY_HOST_COHERENT_BIT property still require memory barriers between host and device in order to be coherent, but do not require additional cache management operations (FlushMappedMemoryRanges or InvalidateMappedMemoryRanges) to achieve coherency. For host writes to be seen by subsequent command buffer operations, a pipeline barrier from a source of ACCESS_HOST_WRITE_BIT and PIPELINE_STAGE_HOST_BIT to a destination of the relevant device pipeline stages and access types must be performed. Note that such a barrier is performed implicitly upon each command buffer submission, so an explicit barrier is only rarely needed (e.g. if a command buffer waits upon an event signaled by the host, where the host wrote some data after submission). For device writes to be seen by subsequent host reads, a pipeline barrier is required to make the writes visible.

        Valid Usage
        • device must be a valid VkDevice handle
        • memory must be a valid VkDeviceMemory handle
        • flags must be 0
        • ppData must be a pointer to a pointer
        • memory must have been created, allocated or retrieved from device
        • Each of device and memory must have been created, allocated or retrieved from the same VkPhysicalDevice
        • memory must not currently be mapped
        • offset must be less than the size of memory
        • If size is not equal to WHOLE_SIZE, size must be greater than 0
        • If size is not equal to WHOLE_SIZE, size must be less than or equal to the size of the memory minus offset
        • memory must have been created with a memory type that reports MEMORY_PROPERTY_HOST_VISIBLE_BIT
        Host Synchronization
        • Host access to memory must be externally synchronized
        Parameters:
        device - the logical device that owns the memory
        memory - the VkDeviceMemory object to be mapped
        offset - a zero-based byte offset from the beginning of the memory object
        size - he size of the memory range to map, or WHOLE_SIZE to map from offset to the end of the allocation
        flags - reserved for future use, and must be zero
        ppData - points to a pointer in which is returned a host-accessible pointer to the beginning of the mapped range. This pointer minus offset must be aligned to at least VkPhysicalDeviceLimits::minMemoryMapAlignment.
      • vkUnmapMemory

        public static void vkUnmapMemory(VkDevice device,
                                         long memory)

        Khronos Reference Page

        Unmaps a previously mapped memory object.
        Valid Usage
        • device must be a valid VkDevice handle
        • memory must be a valid VkDeviceMemory handle
        • memory must have been created, allocated or retrieved from device
        • Each of device and memory must have been created, allocated or retrieved from the same VkPhysicalDevice
        • memory must currently be mapped
        Host Synchronization
        • Host access to memory must be externally synchronized
        Parameters:
        device - the logical device that owns the memory
        memory - the memory object to be unmapped
      • vkFlushMappedMemoryRanges

        public static int vkFlushMappedMemoryRanges(VkDevice device,
                                                    VkMappedMemoryRange.Buffer pMemoryRanges)

        Khronos Reference Page

        Flushes ranges of non-coherent memory from the host caches.
        Valid Usage
        • device must be a valid VkDevice handle
        • pMemoryRanges must be a pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures
        • memoryRangeCount must be greater than 0

        vkFlushMappedMemoryRanges must be used to guarantee that host writes to non-coherent memory are visible to the device. It must be called after the host writes to non-coherent memory have completed and before command buffers that will read or write any of those memory locations are submitted to a queue.

        Parameters:
        device - the logical device that owns the memory ranges
        pMemoryRanges - a pointer to an array of VkMappedMemoryRange structures describing the memory ranges to flush
      • vkFlushMappedMemoryRanges

        public static int vkFlushMappedMemoryRanges(VkDevice device,
                                                    VkMappedMemoryRange pMemoryRange)

        Khronos Reference Page

        Flushes ranges of non-coherent memory from the host caches.
        Valid Usage
        • device must be a valid VkDevice handle
        • pMemoryRanges must be a pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures
        • memoryRangeCount must be greater than 0

        vkFlushMappedMemoryRanges must be used to guarantee that host writes to non-coherent memory are visible to the device. It must be called after the host writes to non-coherent memory have completed and before command buffers that will read or write any of those memory locations are submitted to a queue.

        Parameters:
        device - the logical device that owns the memory ranges
      • vkInvalidateMappedMemoryRanges

        public static int vkInvalidateMappedMemoryRanges(VkDevice device,
                                                         VkMappedMemoryRange.Buffer pMemoryRanges)

        Khronos Reference Page

        Invalidates ranges of mapped memory objects.
        Valid Usage
        • device must be a valid VkDevice handle
        • pMemoryRanges must be a pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures
        • memoryRangeCount must be greater than 0

        vkInvalidateMappedMemoryRanges must be used to guarantee that device writes to non-coherent memory are visible to the host. It must be called after command buffers that execute and flush (via memory barriers) the device writes have completed, and before the host will read or write any of those locations. If a range of non-coherent memory is written by the host and then invalidated without first being flushed, its contents are undefined.

        Parameters:
        device - the logical device that owns the memory ranges
        pMemoryRanges - a pointer to an array of VkMappedMemoryRange structures describing the memory ranges to invalidate
      • vkInvalidateMappedMemoryRanges

        public static int vkInvalidateMappedMemoryRanges(VkDevice device,
                                                         VkMappedMemoryRange pMemoryRange)

        Khronos Reference Page

        Invalidates ranges of mapped memory objects.
        Valid Usage
        • device must be a valid VkDevice handle
        • pMemoryRanges must be a pointer to an array of memoryRangeCount valid VkMappedMemoryRange structures
        • memoryRangeCount must be greater than 0

        vkInvalidateMappedMemoryRanges must be used to guarantee that device writes to non-coherent memory are visible to the host. It must be called after command buffers that execute and flush (via memory barriers) the device writes have completed, and before the host will read or write any of those locations. If a range of non-coherent memory is written by the host and then invalidated without first being flushed, its contents are undefined.

        Parameters:
        device - the logical device that owns the memory ranges
      • vkGetDeviceMemoryCommitment

        public static void vkGetDeviceMemoryCommitment(VkDevice device,
                                                       long memory,
                                                       java.nio.LongBuffer pCommittedMemoryInBytes)

        Khronos Reference Page

        Determines the amount of lazily-allocated memory that is currently committed for a memory object.

        If the memory object is allocated from a heap with the MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set, that object’s backing memory may be provided by the implementation lazily. The actual committed size of the memory may initially be as small as zero (or as large as the requested size), and monotonically increases as additional memory is needed.

        A memory type with this flag set is only allowed to be bound to a VkImage whose usage flags include IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT.

        Note

        Using lazily allocated memory objects for framebuffer attachments that are not needed once a render pass instance has completed may allow some implementations to never allocate memory for such attachments.

        Valid Usage
        • device must be a valid VkDevice handle
        • memory must be a valid VkDeviceMemory handle
        • pCommittedMemoryInBytes must be a pointer to a VkDeviceSize value
        • memory must have been created, allocated or retrieved from device
        • Each of device and memory must have been created, allocated or retrieved from the same VkPhysicalDevice
        • memory must have been created with a memory type that reports MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT

        The implementation may update the commitment at any time, and the value returned by this query may be out of date.

        The implementation guarantees to allocate any committed memory from the heapIndex indicated by the memory type that the memory object was created with.

        Parameters:
        device - the logical device that owns the memory
        memory - the memory object being queried
        pCommittedMemoryInBytes - a pointer to a VkDeviceSize value in which the number of bytes currently committed is returned, on success
      • vkBindBufferMemory

        public static int vkBindBufferMemory(VkDevice device,
                                             long buffer,
                                             long memory,
                                             long memoryOffset)

        Khronos Reference Page

        Attaches memory to a buffer object.
        Valid Usage
        • device must be a valid VkDevice handle
        • buffer must be a valid VkBuffer handle
        • memory must be a valid VkDeviceMemory handle
        • buffer must have been created, allocated or retrieved from device
        • memory must have been created, allocated or retrieved from device
        • Each of device, buffer and memory must have been created, allocated or retrieved from the same VkPhysicalDevice
        • buffer must not already be backed by a memory object
        • buffer must not have been created with any sparse memory binding flags
        • memoryOffset must be less than the size of memory
        • If buffer was created with the BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment
        • If buffer was created with the BUFFER_USAGE_UNIFORM_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment
        • If buffer was created with the BUFFER_USAGE_STORAGE_BUFFER_BIT, memoryOffset must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment
        • memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to GetBufferMemoryRequirements with buffer
        • The size of buffer must be less than or equal to the size of memory minus memoryOffset
        • memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to GetBufferMemoryRequirements with buffer
        Host Synchronization
        • Host access to buffer must be externally synchronized
        Parameters:
        device - the logical device that owns the buffer and memory
        buffer - the buffer
        memory - a VkDeviceMemory object describing the device memory to attach
        memoryOffset - the start offset of the region of memory which is to be bound to the buffer. The number of bytes returned in the VkMemoryRequirements::size member in memory, starting from memoryOffset bytes, will be bound to the specified buffer.
      • vkBindImageMemory

        public static int vkBindImageMemory(VkDevice device,
                                            long image,
                                            long memory,
                                            long memoryOffset)

        Khronos Reference Page

        Attaches memory to an image object.
        Valid Usage
        • device must be a valid VkDevice handle
        • image must be a valid VkImage handle
        • memory must be a valid VkDeviceMemory handle
        • image must have been created, allocated or retrieved from device
        • memory must have been created, allocated or retrieved from device
        • Each of device, image and memory must have been created, allocated or retrieved from the same VkPhysicalDevice
        • image must not already be backed by a memory object
        • image must not have been created with any sparse memory binding flags
        • memoryOffset must be less than the size of memory
        • memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to GetImageMemoryRequirements with image
        • memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to GetImageMemoryRequirements with image
        • The size member of the VkMemoryRequirements structure returned from a call to GetImageMemoryRequirements with image must be less than or equal to the size of memory minus memoryOffset
        Host Synchronization
        • Host access to image must be externally synchronized
        Parameters:
        device - the logical device that owns the image and memory
        image - the image
        memory - a VkDeviceMemory object describing the device memory to attach
        memoryOffset - the start offset of the region of memory which is to be bound to the image. The number of bytes returned in the VkMemoryRequirements::size member in memory, starting from memoryOffset bytes, will be bound to the specified image.
      • vkGetBufferMemoryRequirements

        public static void vkGetBufferMemoryRequirements(VkDevice device,
                                                         long buffer,
                                                         VkMemoryRequirements pMemoryRequirements)

        Khronos Reference Page

        Determines the memory requirements for a non-sparse buffer resource.
        Valid Usage
        • device must be a valid VkDevice handle
        • buffer must be a valid VkBuffer handle
        • pMemoryRequirements must be a pointer to a VkMemoryRequirements structure
        • buffer must have been created, allocated or retrieved from device
        • Each of device and buffer must have been created, allocated or retrieved from the same VkPhysicalDevice
        Parameters:
        device - the logical device that owns the buffer
        buffer - the buffer to query
        pMemoryRequirements - points to an instance of the VkMemoryRequirements structure in which the memory requirements of the buffer object are returned
      • vkGetImageMemoryRequirements

        public static void vkGetImageMemoryRequirements(VkDevice device,
                                                        long image,
                                                        VkMemoryRequirements pMemoryRequirements)

        Khronos Reference Page

        Determines the memory requirements for a non-sparse image resource.
        Valid Usage
        • device must be a valid VkDevice handle
        • image must be a valid VkImage handle
        • pMemoryRequirements must be a pointer to a VkMemoryRequirements structure
        • image must have been created, allocated or retrieved from device
        • Each of device and image must have been created, allocated or retrieved from the same VkPhysicalDevice
        Parameters:
        device - the logical device that owns the image
        image - the image to query
        pMemoryRequirements - points to an instance of the VkMemoryRequirements structure in which the memory requirements of the image object are returned
      • vkGetImageSparseMemoryRequirements

        public static void vkGetImageSparseMemoryRequirements(VkDevice device,
                                                              long image,
                                                              java.nio.IntBuffer pSparseMemoryRequirementCount,
                                                              VkSparseImageMemoryRequirements.Buffer pSparseMemoryRequirements)

        Khronos Reference Page

        Query sparse memory requirements for an image.

        If pSparseMemoryRequirements is NULL, then the number of sparse memory requirements available is returned in pSparseMemoryRequirementCount. Otherwise, pSparseMemoryRequirementCount must point to a variable set by the user to the number of elements in the pSparseMemoryRequirements array, and on return the variable is overwritten with the number of structures actually written to pSparseMemoryRequirements. If the value of pSparseMemoryRequirementCount is less than the number of sparse memory requirements available, at most pSparseMemoryRequirementCount structures will be written.

        If the image was not created with IMAGE_CREATE_SPARSE_RESIDENCY_BIT then pSparseMemoryRequirementCount will be set to zero and pSparseMemoryRequirements will not be written to.

        Note

        It is legal for an implementation to report a larger value in VkMemoryRequirements::size than would be obtained by adding together memory sizes for all VkSparseImageMemoryRequirements returned by vkGetImageSparseMemoryRequirements. This may occur when the hardware requires unused padding in the address range describing the resource.

        Valid Usage
        • device must be a valid VkDevice handle
        • image must be a valid VkImage handle
        • pSparseMemoryRequirementCount must be a pointer to a uint32_t value
        • If the value referenced by pSparseMemoryRequirementCount is not 0, and pSparseMemoryRequirements is not NULL, pSparseMemoryRequirements must be a pointer to an array of pSparseMemoryRequirementCount VkSparseImageMemoryRequirements structures
        • image must have been created, allocated or retrieved from device
        • Each of device and image must have been created, allocated or retrieved from the same VkPhysicalDevice
        Parameters:
        device - the logical device that owns the image
        image - the VkImage object to get the memory requirements for
        pSparseMemoryRequirementCount - a pointer to an integer related to the number of sparse memory requirements available or queried
        pSparseMemoryRequirements - either NULL or a pointer to an array of VkSparseImageMemoryRequirements structures
      • vkGetPhysicalDeviceSparseImageFormatProperties

        public static void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,
                                                                          int format,
                                                                          int type,
                                                                          int samples,
                                                                          int usage,
                                                                          int tiling,
                                                                          java.nio.IntBuffer pPropertyCount,
                                                                          VkSparseImageFormatProperties.Buffer pProperties)

        Khronos Reference Page

        Retrieves properties of an image format applied to sparse images.

        Given that certain aspects of sparse image support, including the sparse image block size, may be implementation-dependent, vkGetPhysicalDeviceSparseImageFormatProperties can be used to query for sparse image format properties prior to resource creation. This command is used to check whether a given set of sparse image parameters is supported and what the sparse block shape will be.

        vkGetPhysicalDeviceSparseImageFormatProperties returns an array of VkSparseImageFormatProperties. 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.

        If pProperties is NULL, then the number of sparse format properties available is returned in pPropertyCount. Otherwise, pPropertyCount must point to a variable set by the user to the number of elements in the pProperties array, and on return the variable is overwritten with the number of structures actually written to pProperties. If pPropertyCount is less than the number of sparse format properties available, at most pPropertyCount structures will be written.

        Valid Usage
        • physicalDevice must be a valid VkPhysicalDevice handle
        • format must be a valid VkFormat value
        • type must be a valid VkImageType value
        • samples must be a valid VkSampleCountFlagBits value
        • usage must be a valid combination of VkImageUsageFlagBits values
        • usage must not be 0
        • tiling must be a valid VkImageTiling value
        • pPropertyCount must be a pointer to a uint32_t value
        • If the value referenced by pPropertyCount is not 0, and pProperties is not NULL, pProperties must be a pointer to an array of pPropertyCount VkSparseImageFormatProperties structures
        • If format is an integer format, samples must be one of the bit flags specified in VkPhysicalDeviceLimits::sampledImageIntegerSampleCounts
        • If format is a non-integer color format, samples must be one of the bit flags specified in VkPhysicalDeviceLimits::sampledImageColorSampleCounts
        • If format is a depth format, samples must be one of the bit flags specified in VkPhysicalDeviceLimits::sampledImageDepthSampleCounts
        • If format is a stencil format, samples must be one of the bit flags specified in VkPhysicalDeviceLimits::sampledImageStencilSampleCounts
        • If usage includes IMAGE_USAGE_STORAGE_BIT, samples must be one of the bit flags specified in VkPhysicalDeviceLimits::storageImageSampleCounts

        If IMAGE_CREATE_SPARSE_RESIDENCY_BIT is not supported for the given arguments, pPropertyCount will be set to zero upon return, and no data will be written to pProperties.

        Multiple aspects are returned for depth/stencil images that are implemented as separate planes by the implementation. The depth and stencil data planes each have unique VkSparseImageFormatProperties data.

        Depth/stencil images with depth and stencil data interleaved into a single plane will return a single VkSparseImageFormatProperties structure with the aspectMask set to IMAGE_ASPECT_DEPTH_BIT | IMAGE_ASPECT_STENCIL_BIT.

        Parameters:
        physicalDevice - the physical device from which to query the sparse image capabilities
        format - the image format
        type - the dimensionality of image. One of:
        IMAGE_TYPE_1DIMAGE_TYPE_2DIMAGE_TYPE_3D
        samples - the number of samples per pixel as defined in VkSampleCountFlagBits. One of:
        SAMPLE_COUNT_1_BITSAMPLE_COUNT_2_BITSAMPLE_COUNT_4_BITSAMPLE_COUNT_8_BIT
        SAMPLE_COUNT_16_BITSAMPLE_COUNT_32_BITSAMPLE_COUNT_64_BIT
        usage - a bitfield describing the intended usage of the image. One or more of:
        IMAGE_USAGE_TRANSFER_SRC_BITIMAGE_USAGE_TRANSFER_DST_BIT
        IMAGE_USAGE_SAMPLED_BITIMAGE_USAGE_STORAGE_BIT
        IMAGE_USAGE_COLOR_ATTACHMENT_BITIMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
        IMAGE_USAGE_TRANSIENT_ATTACHMENT_BITIMAGE_USAGE_INPUT_ATTACHMENT_BIT
        tiling - the tiling arrangement of the data elements in memory. One of:
        IMAGE_TILING_OPTIMALIMAGE_TILING_LINEAR
        pPropertyCount - a pointer to an integer related to the number of sparse format properties available or queried
        pProperties - either NULL or a pointer to an array of VkSparseImageFormatProperties structures
      • vkQueueBindSparse

        public static int vkQueueBindSparse(VkQueue queue,
                                            VkBindSparseInfo.Buffer pBindInfo,
                                            long fence)

        Khronos Reference Page

        Submits sparse binding operations to a queue for execution.

        Each batch of sparse binding operations is represented by a list of VkSparseBufferMemoryBindInfo, VkSparseImageOpaqueMemoryBindInfo, and VkSparseImageMemoryBindInfo structures (encapsulated in a VkBindSparseInfo structure), each preceded by a list of semaphores upon which to wait before beginning execution of the operations, and followed by a second list of semaphores to signal upon completion of the operations.

        When all sparse binding operations in pBindInfo have completed execution, the status of fence is set to signaled, providing certain implicit ordering guarantees.

        Within a batch, a given range of a resource must not be bound more than once. Across batches, if a range is to be bound to one allocation and offset and then to another allocation and offset, then the application must guarantee (usually using semaphores) that the binding operations are executed in the correct order, as well as to order binding operations against the execution of command buffer submissions.

        Valid Usage
        • queue must be a valid VkQueue handle
        • If bindInfoCount is not 0, pBindInfo must be a pointer to an array of bindInfoCount valid VkBindSparseInfo structures
        • If fence is not NULL_HANDLE, fence must be a valid VkFence handle
        • The queue must support sparse binding operations
        • Each of queue and fence that are valid handles must have been created, allocated or retrieved from the same VkDevice
        • fence must be unsignaled
        • fence must not be associated with any other queue command that has not yet completed execution on that queue
        Host Synchronization
        • Host access to queue must be externally synchronized
        • Host access to pBindInfo[].pWaitSemaphores[] must be externally synchronized
        • Host access to pBindInfo[].pSignalSemaphores[] must be externally synchronized
        • Host access to pBindInfo[].pBufferBinds[].buffer must be externally synchronized
        • Host access to pBindInfo[].pImageOpaqueBinds[].image must be externally synchronized
        • Host access to pBindInfo[].pImageBinds[].image must be externally synchronized
        • Host access to fence must be externally synchronized
        Parameters:
        queue - the queue to submit the sparse binding operation to
        pBindInfo - an array of VkBindSparseInfo structures each specifying the parameters of a sparse binding operation batch
        fence - if not NULL_HANDLE, is a fence to be signaled once the sparse binding operation completes
      • vkQueueBindSparse

        public static int vkQueueBindSparse(VkQueue queue,
                                            VkBindSparseInfo pBindInfo,
                                            long fence)

        Khronos Reference Page

        Submits sparse binding operations to a queue for execution.

        Each batch of sparse binding operations is represented by a list of VkSparseBufferMemoryBindInfo, VkSparseImageOpaqueMemoryBindInfo, and VkSparseImageMemoryBindInfo structures (encapsulated in a VkBindSparseInfo structure), each preceded by a list of semaphores upon which to wait before beginning execution of the operations, and followed by a second list of semaphores to signal upon completion of the operations.

        When all sparse binding operations in pBindInfo have completed execution, the status of fence is set to signaled, providing certain implicit ordering guarantees.

        Within a batch, a given range of a resource must not be bound more than once. Across batches, if a range is to be bound to one allocation and offset and then to another allocation and offset, then the application must guarantee (usually using semaphores) that the binding operations are executed in the correct order, as well as to order binding operations against the execution of command buffer submissions.

        Valid Usage
        • queue must be a valid VkQueue handle
        • If bindInfoCount is not 0, pBindInfo must be a pointer to an array of bindInfoCount valid VkBindSparseInfo structures
        • If fence is not NULL_HANDLE, fence must be a valid VkFence handle
        • The queue must support sparse binding operations
        • Each of queue and fence that are valid handles must have been created, allocated or retrieved from the same VkDevice
        • fence must be unsignaled
        • fence must not be associated with any other queue command that has not yet completed execution on that queue
        Host Synchronization
        • Host access to queue must be externally synchronized
        • Host access to pBindInfo[].pWaitSemaphores[] must be externally synchronized
        • Host access to pBindInfo[].pSignalSemaphores[] must be externally synchronized
        • Host access to pBindInfo[].pBufferBinds[].buffer must be externally synchronized
        • Host access to pBindInfo[].pImageOpaqueBinds[].image must be externally synchronized
        • Host access to pBindInfo[].pImageBinds[].image must be externally synchronized
        • Host access to fence must be externally synchronized
        Parameters:
        queue - the queue to submit the sparse binding operation to
        pBindInfo - an array of VkBindSparseInfo structures each specifying the parameters of a sparse binding operation batch
        fence - if not NULL_HANDLE, is a fence to be signaled once the sparse binding operation completes
      • vkCreateFence

        public static int vkCreateFence(VkDevice device,
                                        VkFenceCreateInfo pCreateInfo,
                                        VkAllocationCallbacks pAllocator,
                                        java.nio.LongBuffer pFence)

        Khronos Reference Page

        Creates a new fence object.

        Fences can be used by the host to determine completion of execution of submissions to queues performed with QueueSubmit and QueueBindSparse.

        A fence’s status is always either signaled or unsignaled. The host can poll the status of a single fence, or wait for any or all of a group of fences to become signaled.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkFenceCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pFence must be a pointer to a VkFence handle
        Parameters:
        device - the logical device that creates the fence
        pCreateInfo - points to a VkFenceCreateInfo structure specifying the state of the fence object
        pAllocator - controls host memory allocation
        pFence - points to a handle in which the resulting fence object is returned
      • vkDestroyFence

        public static void vkDestroyFence(VkDevice device,
                                          long fence,
                                          VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a fence object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If fence is not NULL_HANDLE, fence must be a valid VkFence handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If fence is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and fence that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • fence must not be associated with any queue command that has not yet completed execution on that queue
        • If VkAllocationCallbacks were provided when fence was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when fence was created, pAllocator must be NULL
        Host Synchronization
        • Host access to fence must be externally synchronized
        Parameters:
        device - the logical device that destroys the fence
        fence - the handle of the fence to destroy
        pAllocator - controls host memory allocation
      • vkResetFences

        public static int vkResetFences(VkDevice device,
                                        java.nio.LongBuffer pFences)

        Khronos Reference Page

        Resets the status of one or more fences to the unsignaled state.

        If a fence is already in the unsignaled state, then resetting it has no effect.

        Valid Usage
        • device must be a valid VkDevice handle
        • pFences must be a pointer to an array of fenceCount valid VkFence handles
        • fenceCount must be greater than 0
        • Each element of pFences must have been created, allocated or retrieved from device
        • Each of device and the elements of pFences must have been created, allocated or retrieved from the same VkPhysicalDevice
        • Any given element of pFences must not currently be associated with any queue command that has not yet completed execution on that queue
        Host Synchronization
        • Host access to each member of pFences must be externally synchronized
        Parameters:
        device - the logical device that owns the fences
        pFences - a pointer to an array of fenceCount fence handles to reset
      • vkResetFences

        public static int vkResetFences(VkDevice device,
                                        long pFence)

        Khronos Reference Page

        Resets the status of one or more fences to the unsignaled state.

        If a fence is already in the unsignaled state, then resetting it has no effect.

        Valid Usage
        • device must be a valid VkDevice handle
        • pFences must be a pointer to an array of fenceCount valid VkFence handles
        • fenceCount must be greater than 0
        • Each element of pFences must have been created, allocated or retrieved from device
        • Each of device and the elements of pFences must have been created, allocated or retrieved from the same VkPhysicalDevice
        • Any given element of pFences must not currently be associated with any queue command that has not yet completed execution on that queue
        Host Synchronization
        • Host access to each member of pFences must be externally synchronized
        Parameters:
        device - the logical device that owns the fences
      • vkGetFenceStatus

        public static int vkGetFenceStatus(VkDevice device,
                                           long fence)

        Khronos Reference Page

        Queries the status of a fence from the host.

        Upon success, vkGetFenceStatus returns the status of the fence, which is one of:

        • SUCCESS indicates that the fence is signaled.
        • NOT_READY indicates that the fence is unsignaled.
        Valid Usage
        • device must be a valid VkDevice handle
        • fence must be a valid VkFence handle
        • fence must have been created, allocated or retrieved from device
        • Each of device and fence must have been created, allocated or retrieved from the same VkPhysicalDevice
        Parameters:
        device - the logical device that owns the fence
        fence - the handle of the fence to query
      • vkWaitForFences

        public static int vkWaitForFences(VkDevice device,
                                          java.nio.LongBuffer pFences,
                                          int waitAll,
                                          long timeout)

        Khronos Reference Page

        Causes the host to wait until any one or all of a group of fences is signaled.

        If the condition is satisfied when vkWaitForFences is called, then vkWaitForFences returns immediately. If the condition is not satisfied at the time vkWaitForFences is called, then vkWaitForFences will block and wait up to timeout nanoseconds for the condition to become satisfied.

        If timeout is zero, then vkWaitForFences does not wait, but simply returns the current state of the fences. TIMEOUT will be returned in this case if the condition is not satisfied, even though no actual wait was performed.

        If the specified timeout period expires before the condition is satisfied, vkWaitForFences returns TIMEOUT. If the condition is satisfied before timeout nanoseconds has expired, vkWaitForFences returns SUCCESS.

        Fences become signaled when the device completes executing the work that was submitted to a queue accompanied by the fence. But this alone is not sufficient for the host to be guaranteed to see the results of device writes to memory. To provide that guarantee, the application must insert a memory barrier between the device writes and the end of the submission that will signal the fence, with dstAccessMask having the ACCESS_HOST_READ_BIT bit set, with dstStageMask having the PIPELINE_STAGE_HOST_BIT bit set, and with the appropriate srcStageMask and srcAccessMask members set to guarantee completion of the writes. If the memory was allocated without the MEMORY_PROPERTY_HOST_COHERENT_BIT set, then InvalidateMappedMemoryRanges must be called after the fence is signaled in order to ensure the writes are visible to the host.

        Valid Usage
        • device must be a valid VkDevice handle
        • pFences must be a pointer to an array of fenceCount valid VkFence handles
        • fenceCount must be greater than 0
        • Each element of pFences must have been created, allocated or retrieved from device
        • Each of device and the elements of pFences must have been created, allocated or retrieved from the same VkPhysicalDevice
        Parameters:
        device - the logical device that owns the fences
        pFences - a pointer to an array of fenceCount fence handles
        waitAll - the condition that must be satisfied to successfully unblock the wait. If waitAll is TRUE, then the condition is that all fences in pFences are signaled. Otherwise, the condition is that at least one fence in pFences is signaled.
        timeout - the timeout period in units of nanoseconds. timeout is adjusted to the closest value allowed by the implementation-dependent timeout accuracy, which may be substantially longer than one nanosecond, and may be longer than the requested period.
      • vkWaitForFences

        public static int vkWaitForFences(VkDevice device,
                                          long pFence,
                                          int waitAll,
                                          long timeout)

        Khronos Reference Page

        Causes the host to wait until any one or all of a group of fences is signaled.

        If the condition is satisfied when vkWaitForFences is called, then vkWaitForFences returns immediately. If the condition is not satisfied at the time vkWaitForFences is called, then vkWaitForFences will block and wait up to timeout nanoseconds for the condition to become satisfied.

        If timeout is zero, then vkWaitForFences does not wait, but simply returns the current state of the fences. TIMEOUT will be returned in this case if the condition is not satisfied, even though no actual wait was performed.

        If the specified timeout period expires before the condition is satisfied, vkWaitForFences returns TIMEOUT. If the condition is satisfied before timeout nanoseconds has expired, vkWaitForFences returns SUCCESS.

        Fences become signaled when the device completes executing the work that was submitted to a queue accompanied by the fence. But this alone is not sufficient for the host to be guaranteed to see the results of device writes to memory. To provide that guarantee, the application must insert a memory barrier between the device writes and the end of the submission that will signal the fence, with dstAccessMask having the ACCESS_HOST_READ_BIT bit set, with dstStageMask having the PIPELINE_STAGE_HOST_BIT bit set, and with the appropriate srcStageMask and srcAccessMask members set to guarantee completion of the writes. If the memory was allocated without the MEMORY_PROPERTY_HOST_COHERENT_BIT set, then InvalidateMappedMemoryRanges must be called after the fence is signaled in order to ensure the writes are visible to the host.

        Valid Usage
        • device must be a valid VkDevice handle
        • pFences must be a pointer to an array of fenceCount valid VkFence handles
        • fenceCount must be greater than 0
        • Each element of pFences must have been created, allocated or retrieved from device
        • Each of device and the elements of pFences must have been created, allocated or retrieved from the same VkPhysicalDevice
        Parameters:
        device - the logical device that owns the fences
        waitAll - the condition that must be satisfied to successfully unblock the wait. If waitAll is TRUE, then the condition is that all fences in pFences are signaled. Otherwise, the condition is that at least one fence in pFences is signaled.
        timeout - the timeout period in units of nanoseconds. timeout is adjusted to the closest value allowed by the implementation-dependent timeout accuracy, which may be substantially longer than one nanosecond, and may be longer than the requested period.
      • vkCreateSemaphore

        public static int vkCreateSemaphore(VkDevice device,
                                            VkSemaphoreCreateInfo pCreateInfo,
                                            VkAllocationCallbacks pAllocator,
                                            java.nio.LongBuffer pSemaphore)

        Khronos Reference Page

        Creates a new queue semaphore object.

        Semaphores are used to coordinate operations between queues and between queue submissions within a single queue. An application might associate semaphores with resources or groups of resources to marshal ownership of shared data. A semaphore’s status is always either signaled or unsignaled. Semaphores are signaled by queues and can also be waited on in the same or different queues until they are signaled.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkSemaphoreCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pSemaphore must be a pointer to a VkSemaphore handle

        To signal a semaphore from a queue, include it in an element of the array of VkSubmitInfo structures passed through the pSubmits parameter to a call to QueueSubmit, or in an element of the array of VkBindSparseInfo structures passed through the pBindInfo parameter to a call to QueueBindSparse.

        Semaphores included in the pSignalSemaphores array of one of the elements of a queue submission are signaled once queue execution reaches the signal operation, and all previous work in the queue completes. Any operations waiting on that semaphore in other queues will be released once it is signaled.

        Similarly, to wait on a semaphore from a queue, include it in the pWaitSemaphores array of one of the elements of a batch in a queue submission. When queue execution reaches the wait operation, will stall execution of subsequently submitted operations until the semaphore reaches the signaled state due to a signaling operation. Once the semaphore is signaled, the subsequent operations will be permitted to execute and the status of the semaphore will be reset to the unsignaled state.

        In the case of VkSubmitInfo, command buffers wait at specific pipeline stages, rather than delaying the entire command buffer’s execution, with the pipeline stages determined by the value of the corresponding element of the pWaitDstStageMask member of VkSubmitInfo. Execution of work by those stages in subsequent commands is stalled until the corresponding semaphore reaches the signaled state. Subsequent sparse binding operations wait for the semaphore to become signaled, regardless of the values of pWaitDstStageMask.

        Note

        A common scenario for using pWaitDstStageMask with values other than PIPELINE_STAGE_ALL_COMMANDS_BIT is when synchronizing a window system presentation operation against subsequent command buffers which render the next frame. In this case, an image that was being presented must not be overwritten until the presentation operation completes, but other pipeline stages can execute without waiting. A mask of PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT prevents subsequent color attachment writes from executing until the semaphore signals. Some implementations may be able to execute transfer operations and/or vertex processing work before the semaphore is signaled.

        If an image layout transition needs to be performed on a swapchain image before it is used in a framebuffer, that can be performed as the first operation submitted to the queue after acquiring the image, and should not prevent other work from overlapping with the presentation operation. For example, a VkImageMemoryBarrier could use:

        Alternately, oldLayout can be IMAGE_LAYOUT_UNDEFINED, if the image’s contents need not be preserved.

        This barrier accomplishes a dependency chain between previous presentation operations and subsequent color attachment output operations, with the layout transition performed in between, and does not introduce a dependency between previous work and any vertex processing stages. More precisely, the semaphore signals after the presentation operation completes, then the semaphore wait stalls the PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT stage, then there is a dependency from that same stage to itself with the layout transition performed in between.

        When a queue signals or waits upon a semaphore, certain implicit ordering guarantees are provided.

        Semaphore operations may not make the side effects of commands visible to the host.

        Parameters:
        device - the logical device that creates the semaphore
        pCreateInfo - points to a VkSemaphoreCreateInfo structure specifying the state of the semaphore object
        pAllocator - controls host memory allocation
        pSemaphore - points to a handle in which the resulting semaphore object is returned. The semaphore is created in the unsignaled state.
      • vkDestroySemaphore

        public static void vkDestroySemaphore(VkDevice device,
                                              long semaphore,
                                              VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a semaphore object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If semaphore is not NULL_HANDLE, semaphore must be a valid VkSemaphore handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If semaphore is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and semaphore that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • semaphore must not be associated with any queue command that has not yet completed execution on that queue
        • If VkAllocationCallbacks were provided when semaphore was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when semaphore was created, pAllocator must be NULL
        Host Synchronization
        • Host access to semaphore must be externally synchronized
        Parameters:
        device - the logical device that destroys the semaphore
        semaphore - the handle of the semaphore to destroy
        pAllocator - controls host memory allocation
      • vkCreateEvent

        public static int vkCreateEvent(VkDevice device,
                                        VkEventCreateInfo pCreateInfo,
                                        VkAllocationCallbacks pAllocator,
                                        java.nio.LongBuffer pEvent)

        Khronos Reference Page

        Creates a new event object.

        Events represent a fine-grained synchronization primitive that can be used to gauge progress through a sequence of commands executed on a queue by Vulkan. An event is initially in the unsignaled state. It can be signaled by a device, using commands inserted into the command buffer, or by the host. It can also be reset to the unsignaled state by a device or the host. The host can query the state of an event. A device can wait for one or more events to become signaled.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkEventCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pEvent must be a pointer to a VkEvent handle
        Parameters:
        device - the logical device that creates the event
        pCreateInfo - a pointer to an instance of the VkEventCreateInfo structure which contains information about how the event is to be created
        pAllocator - controls host memory allocation
        pEvent - points to a handle in which the resulting event object is returned
      • vkDestroyEvent

        public static void vkDestroyEvent(VkDevice device,
                                          long event,
                                          VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys an event object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If event is not NULL_HANDLE, event must be a valid VkEvent handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If event is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and event that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to event must have completed execution
        • If VkAllocationCallbacks were provided when event was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when event was created, pAllocator must be NULL
        Host Synchronization
        • Host access to event must be externally synchronized
        Parameters:
        device - the logical device that destroys the event
        event - the handle of the event to destroy
        pAllocator - controls host memory allocation
      • vkGetEventStatus

        public static int vkGetEventStatus(VkDevice device,
                                           long event)

        Khronos Reference Page

        Queries the state of an event from the host.

        Upon success, vkGetEventStatus returns the state of the event object with the following return codes:

        • EVENT_SET - The event specified by event is signaled.
        • EVENT_RESET - The event specified by event is unsignaled.

        The state of an event can be updated by the host. The state of the event is immediately changed, and subsequent calls to vkGetEventStatus will return the new state. If an event is already in the requested state, then updating it to the same state has no effect.

        Valid Usage
        • device must be a valid VkDevice handle
        • event must be a valid VkEvent handle
        • event must have been created, allocated or retrieved from device
        • Each of device and event must have been created, allocated or retrieved from the same VkPhysicalDevice
        Parameters:
        device - the logical device that owns the event
        event - the handle of the event to query
      • vkSetEvent

        public static int vkSetEvent(VkDevice device,
                                     long event)

        Khronos Reference Page

        Sets the state of an event to signaled from the host.
        Valid Usage
        • device must be a valid VkDevice handle
        • event must be a valid VkEvent handle
        • event must have been created, allocated or retrieved from device
        • Each of device and event must have been created, allocated or retrieved from the same VkPhysicalDevice
        Host Synchronization
        • Host access to event must be externally synchronized
        Parameters:
        device - the logical device that owns the event
        event - the event to set
      • vkResetEvent

        public static int vkResetEvent(VkDevice device,
                                       long event)

        Khronos Reference Page

        Sets the state of an event to unsignaled from the host.
        Valid Usage
        • device must be a valid VkDevice handle
        • event must be a valid VkEvent handle
        • event must have been created, allocated or retrieved from device
        • Each of device and event must have been created, allocated or retrieved from the same VkPhysicalDevice
        • event must not be waited on by a CmdWaitEvents command that is currently executing
        Host Synchronization
        • Host access to event must be externally synchronized
        Parameters:
        device - the logical device that owns the event
        event - the event to reset
      • vkCreateQueryPool

        public static int vkCreateQueryPool(VkDevice device,
                                            VkQueryPoolCreateInfo pCreateInfo,
                                            VkAllocationCallbacks pAllocator,
                                            java.nio.LongBuffer pQueryPool)

        Khronos Reference Page

        Creates a new query pool object.

        Queries are managed using query pool objects. Each query pool is a collection of a specific number of queries of a particular type.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkQueryPoolCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pQueryPool must be a pointer to a VkQueryPool handle
        Parameters:
        device - the logical device that creates the query pool
        pCreateInfo - pointer to an instance of the VkQueryPoolCreateInfo structure containing the number and type of queries to be managed by the pool
        pAllocator - controls host memory allocation
        pQueryPool - a pointer to a VkQueryPool handle in which the resulting query pool object is returned
      • vkDestroyQueryPool

        public static void vkDestroyQueryPool(VkDevice device,
                                              long queryPool,
                                              VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a query pool object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If queryPool is not NULL_HANDLE, queryPool must be a valid VkQueryPool handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If queryPool is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and queryPool that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to queryPool must have completed execution
        • If VkAllocationCallbacks were provided when queryPool was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when queryPool was created, pAllocator must be NULL
        Host Synchronization
        • Host access to queryPool must be externally synchronized
        Parameters:
        device - the logical device that destroys the query pool
        queryPool - the query pool to destroy
        pAllocator - controls host memory allocation
      • vkGetQueryPoolResults

        public static int vkGetQueryPoolResults(VkDevice device,
                                                long queryPool,
                                                int firstQuery,
                                                int queryCount,
                                                java.nio.ByteBuffer pData,
                                                long stride,
                                                int flags)

        Khronos Reference Page

        Retrieves status and results for a set of queries.

        If no bits are set in flags, and all requested queries are in the available state, results are written as an array of 32-bit unsigned integer values. The behavior when not all queries are available, is described below.

        If QUERY_RESULT_64_BIT is not set and the result overflows a 32-bit value, the value may either wrap or saturate. Similarly, if QUERY_RESULT_64_BIT is set and the result overflows a 64-bit value, the value may either wrap or saturate.

        If QUERY_RESULT_WAIT_BIT is set, Vulkan will wait for each query to be in the available state before retrieving the numerical results for that query. In this case, vkGetQueryPoolResults is guaranteed to succeed and return SUCCESS if the queries become available in a finite time (i.e. if they have been issued and not reset). If queries will never finish (e.g. due to being reset but not issued), then vkGetQueryPoolResults may not return in finite time.

        If QUERY_RESULT_WAIT_BIT and QUERY_RESULT_PARTIAL_BIT are both not set then no result values are written to pData for queries that are in the unavailable state at the time of the call, and vkGetQueryPoolResults returns NOT_READY. However, availability state is still written to pData for those queries if QUERY_RESULT_WITH_AVAILABILITY_BIT is set.

        Note

        Applications must take care to ensure that use of the QUERY_RESULT_WAIT_BIT bit has the desired effect.

        For example, if a query has been used previously and a command buffer records the commands CmdResetQueryPool, CmdBeginQuery, and CmdEndQuery for that query, then the query will remain in the available state until the vkCmdResetQueryPool command executes on a queue. Applications can use fences or events to ensure that an query has already been reset before checking for its results or availability status. Otherwise, a stale value could be returned from a previous use of the query.

        The above also applies when QUERY_RESULT_WAIT_BIT is used in combination with QUERY_RESULT_WITH_AVAILABILITY_BIT. In this case, the returned availability status may reflect the result of a previous use of the query unless the vkCmdResetQueryPool command has been executed since the last use of the query.

        Note

        Applications can double-buffer query pool usage, with a pool per frame, and reset queries at the end of the frame in which they are read.

        If QUERY_RESULT_PARTIAL_BIT is set, QUERY_RESULT_WAIT_BIT is not set, and the query’s status is unavailable, an intermediate result value between zero and the final result value is written to pData for that query.

        QUERY_RESULT_PARTIAL_BIT must not be used if the pool’s queryType is QUERY_TYPE_TIMESTAMP.

        If QUERY_RESULT_WITH_AVAILABILITY_BIT is set, the final integer value written for each query is non-zero if the query’s status was available or zero if the status was unavailable. When QUERY_RESULT_WITH_AVAILABILITY_BIT is used, implementations must guarantee that if they return a non-zero availability value then the numerical results must be valid, assuming the results are not reset by a subsequent command.

        Note

        Satisfying this guarantee may require careful ordering by the application, e.g. to read the availability status before reading the results.

        Valid Usage
        • device must be a valid VkDevice handle
        • queryPool must be a valid VkQueryPool handle
        • pData must be a pointer to an array of dataSize bytes
        • flags must be a valid combination of VkQueryResultFlagBits values
        • dataSize must be greater than 0
        • queryPool must have been created, allocated or retrieved from device
        • Each of device and queryPool must have been created, allocated or retrieved from the same VkPhysicalDevice
        • firstQuery must be less than the number of queries in queryPool
        • If QUERY_RESULT_64_BIT is not set in flags then pData and stride must be multiples of 4
        • If QUERY_RESULT_64_BIT is set in flags then pData and stride must be multiples of 8
        • The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool
        • dataSize must be large enough to contain the result of each query, as described here
        • If the queryType used to create queryPool was QUERY_TYPE_TIMESTAMP, flags must not contain QUERY_RESULT_PARTIAL_BIT
        Parameters:
        device - the logical device that owns the query pool
        queryPool - the query pool managing the queries containing the desired results
        firstQuery - the initial query index
        queryCount - the number of queries. firstQuery and queryCount together define a range of queries
        pData - a pointer to a user-allocated buffer where the results will be written
        stride - the stride in bytes between results for individual queries within pData.
        flags - a bitmask of VkQueryResultFlagBits specifying how and when results are returned. One or more of:
        QUERY_RESULT_64_BITQUERY_RESULT_WAIT_BITQUERY_RESULT_WITH_AVAILABILITY_BIT
        QUERY_RESULT_PARTIAL_BIT
      • vkGetQueryPoolResults

        public static int vkGetQueryPoolResults(VkDevice device,
                                                long queryPool,
                                                int firstQuery,
                                                int queryCount,
                                                java.nio.IntBuffer pData,
                                                long stride,
                                                int flags)
      • vkGetQueryPoolResults

        public static int vkGetQueryPoolResults(VkDevice device,
                                                long queryPool,
                                                int firstQuery,
                                                int queryCount,
                                                java.nio.LongBuffer pData,
                                                long stride,
                                                int flags)
      • vkCreateBuffer

        public static int vkCreateBuffer(VkDevice device,
                                         VkBufferCreateInfo pCreateInfo,
                                         VkAllocationCallbacks pAllocator,
                                         java.nio.LongBuffer pBuffer)

        Khronos Reference Page

        Creates a new buffer object.

        Buffers represent linear arrays of data which are used for various purposes by binding them to the graphics pipeline via descriptor sets or via certain commands, or by directly specifying them as parameters to certain commands.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkBufferCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pBuffer must be a pointer to a VkBuffer handle
        • If the flags member of pCreateInfo includes BUFFER_CREATE_SPARSE_BINDING_BIT, creating this VkBuffer must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize
        Parameters:
        device - the logical device that creates the buffer object
        pCreateInfo - a pointer to an instance of the VkBufferCreateInfo structure containing parameters affecting creation of the buffer
        pAllocator - controls host memory allocation
        pBuffer - points to a VkBuffer handle in which the resulting buffer object is returned
      • vkDestroyBuffer

        public static void vkDestroyBuffer(VkDevice device,
                                           long buffer,
                                           VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a buffer object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If buffer is not NULL_HANDLE, buffer must be a valid VkBuffer handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If buffer is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and buffer that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to buffer, either directly or via a VkBufferView, must have completed execution
        • If VkAllocationCallbacks were provided when buffer was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when buffer was created, pAllocator must be NULL
        Host Synchronization
        • Host access to buffer must be externally synchronized
        Parameters:
        device - the logical device that destroys the buffer
        buffer - the buffer to destroy
        pAllocator - controls host memory allocation
      • vkCreateBufferView

        public static int vkCreateBufferView(VkDevice device,
                                             VkBufferViewCreateInfo pCreateInfo,
                                             VkAllocationCallbacks pAllocator,
                                             java.nio.LongBuffer pView)

        Khronos Reference Page

        Creates a new buffer view object.

        A buffer view represents a contiguous range of a buffer and a specific format to be used to interpret the data. Buffer views are used to enable shaders to access buffer contents interpreted as formatted data. In order to create a valid buffer view, the buffer must have been created with at least one of the following usage flags:

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkBufferViewCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pView must be a pointer to a VkBufferView handle
        Parameters:
        device - the logical device that creates the buffer view
        pCreateInfo - a pointer to an instance of the VkBufferViewCreateInfo structure containing parameters to be used to create the buffer
        pAllocator - controls host memory allocation
        pView - points to a VkBufferView handle in which the resulting buffer view object is returned
      • vkDestroyBufferView

        public static void vkDestroyBufferView(VkDevice device,
                                               long bufferView,
                                               VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a buffer view object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If bufferView is not NULL_HANDLE, bufferView must be a valid VkBufferView handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If bufferView is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and bufferView that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to bufferView must have completed execution
        • If VkAllocationCallbacks were provided when bufferView was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when bufferView was created, pAllocator must be NULL
        Host Synchronization
        • Host access to bufferView must be externally synchronized
        Parameters:
        device - the logical device that destroys the buffer view
        bufferView - the buffer view to destroy
        pAllocator - controls host memory allocation
      • vkCreateImage

        public static int vkCreateImage(VkDevice device,
                                        VkImageCreateInfo pCreateInfo,
                                        VkAllocationCallbacks pAllocator,
                                        java.nio.LongBuffer pImage)

        Khronos Reference Page

        Creates a new image object.

        Images represent multidimensional - up to 3 - arrays of data which can be used for various purposes (e.g. attachments, textures), by binding them to the graphics pipeline via descriptor sets, or by directly specifying them as parameters to certain commands.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkImageCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pImage must be a pointer to a VkImage handle
        • If the flags member of pCreateInfo includes IMAGE_CREATE_SPARSE_BINDING_BIT, creating this VkImage must not cause the total required sparse memory for all currently valid sparse resources on the device to exceed VkPhysicalDeviceLimits::sparseAddressSpaceSize
        Parameters:
        device - the logical device that creates the image
        pCreateInfo - a pointer to an instance of the VkImageCreateInfo structure containing parameters to be used to create the image
        pAllocator - controls host memory allocation
        pImage - points to a VkImage handle in which the resulting image object is returned
      • vkDestroyImage

        public static void vkDestroyImage(VkDevice device,
                                          long image,
                                          VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys an image object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If image is not NULL_HANDLE, image must be a valid VkImage handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If image is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and image that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to image, either directly or via a VkImageView, must have completed execution
        • If VkAllocationCallbacks were provided when image was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when image was created, pAllocator must be NULL
        Host Synchronization
        • Host access to image must be externally synchronized
        Parameters:
        device - the logical device that destroys the image
        image - the image to destroy
        pAllocator - controls host memory allocation
      • vkGetImageSubresourceLayout

        public static void vkGetImageSubresourceLayout(VkDevice device,
                                                       long image,
                                                       VkImageSubresource pSubresource,
                                                       VkSubresourceLayout pLayout)

        Khronos Reference Page

        Queries the layout of an image subresource (mipLevel/arrayLayer) of an image created with linear tiling.
        Valid Usage
        • device must be a valid VkDevice handle
        • image must be a valid VkImage handle
        • pSubresource must be a pointer to a valid VkImageSubresource structure
        • pLayout must be a pointer to a VkSubresourceLayout structure
        • image must have been created, allocated or retrieved from device
        • Each of device and image must have been created, allocated or retrieved from the same VkPhysicalDevice
        • image must have been created with tiling equal to IMAGE_TILING_LINEAR
        • The aspectMask member of pSubresource must only have a single bit set
        Parameters:
        device - the logical device that owns the image
        image - the image whose layout is being queried
        pSubresource - a pointer to a VkImageSubresource structure selecting a specific image for the image subresource
        pLayout - points to a VkSubresourceLayout structure in which the layout is returned
      • vkCreateImageView

        public static int vkCreateImageView(VkDevice device,
                                            VkImageViewCreateInfo pCreateInfo,
                                            VkAllocationCallbacks pAllocator,
                                            java.nio.LongBuffer pView)

        Khronos Reference Page

        Creates an image view from an existing image.
        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkImageViewCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pView must be a pointer to a VkImageView handle
        Parameters:
        device - the logical device that creates the image view
        pCreateInfo - a pointer to an instance of the VkImageViewCreateInfo structure containing parameters to be used to create the image view
        pAllocator - controls host memory allocation
        pView - points to a VkImageView handle in which the resulting image view object is returned
      • vkDestroyImageView

        public static void vkDestroyImageView(VkDevice device,
                                              long imageView,
                                              VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys an image view object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If imageView is not NULL_HANDLE, imageView must be a valid VkImageView handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If imageView is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and imageView that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to imageView must have completed execution
        • If VkAllocationCallbacks were provided when imageView was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when imageView was created, pAllocator must be NULL
        Host Synchronization
        • Host access to imageView must be externally synchronized
        Parameters:
        device - the logical device that destroys the image view
        imageView - the image view to destroy
        pAllocator - controls host memory allocation
      • vkCreateShaderModule

        public static int vkCreateShaderModule(VkDevice device,
                                               VkShaderModuleCreateInfo pCreateInfo,
                                               VkAllocationCallbacks pAllocator,
                                               java.nio.LongBuffer pShaderModule)

        Khronos Reference Page

        Creates a new shader module object.

        Shader modules contain shader code and one or more entry points. Shaders are selected from a shader module by specifying an entry point as part of pipeline creation. The stages of a pipeline can use shaders that come from different modules. The shader code defining a shader module must be in the SPIR-V format.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkShaderModuleCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pShaderModule must be a pointer to a VkShaderModule handle
        Parameters:
        device - the logical device that creates the shader module
        pCreateInfo - a pointer to an instance of the VkShaderModuleCreateInfo structure
        pAllocator - controls host memory allocation
        pShaderModule - points to a VkShaderModule handle in which the resulting render pass object is returned
      • vkDestroyShaderModule

        public static void vkDestroyShaderModule(VkDevice device,
                                                 long shaderModule,
                                                 VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a shader module object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If shaderModule is not NULL_HANDLE, shaderModule must be a valid VkShaderModule handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If shaderModule is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and shaderModule that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • If VkAllocationCallbacks were provided when shaderModule was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when shaderModule was created, pAllocator must be NULL
        Host Synchronization
        • Host access to shaderModule must be externally synchronized
        Parameters:
        device - the logical device that destroys the shader module
        shaderModule - the handle of the shader module to destroy
        pAllocator - controls host memory allocation
      • vkCreatePipelineCache

        public static int vkCreatePipelineCache(VkDevice device,
                                                VkPipelineCacheCreateInfo pCreateInfo,
                                                VkAllocationCallbacks pAllocator,
                                                java.nio.LongBuffer pPipelineCache)

        Khronos Reference Page

        Creates a new pipeline cache object.

        Pipeline cache objects allow the result of pipeline construction to be reused between pipelines and between runs of an application. Reuse between pipelines is achieved by passing the same pipeline cache object when creating multiple related pipelines. Reuse across runs of an application is achieved by retrieving pipeline cache contents in one run of an application, saving the contents, and using them to preinitialize a pipeline cache on a subsequent run. The contents of the pipeline cache objects are managed by the implementation. Applications can manage the host memory consumed by a pipeline cache object and control the amount of data retrieved from a pipeline cache object.

        Note

        Applications can track and manage the total host memory size of a pipeline cache object using the pAllocator. Applications can limit the amount of data retrieved from a pipeline cache object in GetPipelineCacheData. Implementations should not internally limit the total number of entries added to a pipeline cache object or the total host memory consumed.

        Once created, a pipeline cache can be passed to the CreateGraphicsPipelines and CreateComputePipelines commands. If the pipeline cache passed into these commands is not NULL_HANDLE, the implementation will query it for possible reuse opportunities and update it with new content. The use of the pipeline cache object in these commands is internally synchronized, and the same pipeline cache object can be used in multiple threads simultaneously.

        Note

        Implementations should make every effort to limit any critical sections to the actual accesses to the cache, which is expected to be significantly shorter than the duration of the vkCreateGraphicsPipelines and vkCreateComputePipelines commands.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkPipelineCacheCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pPipelineCache must be a pointer to a VkPipelineCache handle
        Parameters:
        device - the logical device that creates the pipeline cache object
        pCreateInfo - a pointer to a VkPipelineCacheCreateInfo structure that contains the initial parameters for the pipeline cache object
        pAllocator - controls host memory allocation
        pPipelineCache - a pointer to a VkPipelineCache handle in which the resulting pipeline cache object is returned
      • vkDestroyPipelineCache

        public static void vkDestroyPipelineCache(VkDevice device,
                                                  long pipelineCache,
                                                  VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a pipeline cache object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If pipelineCache is not NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If pipelineCache is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and pipelineCache that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • If VkAllocationCallbacks were provided when pipelineCache was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when pipelineCache was created, pAllocator must be NULL
        Host Synchronization
        • Host access to pipelineCache must be externally synchronized
        Parameters:
        device -
        pipelineCache -
        pAllocator - controls host memory allocation
      • vkGetPipelineCacheData

        public static int vkGetPipelineCacheData(VkDevice device,
                                                 long pipelineCache,
                                                 PointerBuffer pDataSize,
                                                 java.nio.ByteBuffer pData)

        Khronos Reference Page

        Retrieves data from a pipeline cache object.

        If pData is NULL, then the maximum size of the data that can be retrieved from the pipeline cache, in bytes, is returned in pDataSize. Otherwise, pDataSize must point to a variable set by the user to the size of the buffer, in bytes, pointed to by pData, and on return the variable is overwritten with the amount of data actually written to pData.

        If dataSize is less than the maximum size that can be retrieved by the pipeline cache, at most pDataSize bytes will be written to pData, and vkGetPipelineCacheData will return INCOMPLETE. Any data written to pData is valid and can be provided as the pInitialData member of the VkPipelineCacheCreateInfo structure passed to CreatePipelineCache.

        Valid Usage
        • device must be a valid VkDevice handle
        • pipelineCache must be a valid VkPipelineCache handle
        • pDataSize must be a pointer to a size_t value
        • If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a pointer to an array of pDataSize bytes
        • pipelineCache must have been created, allocated or retrieved from device
        • Each of device and pipelineCache must have been created, allocated or retrieved from the same VkPhysicalDevice

        Applications can store the data retrieved from the pipeline cache, and use these data, possibly in a future run of the application, to populate new pipeline cache objects. The results of pipeline compiles, however, may depend on the vendor ID, device ID, driver version, and other details of the device. To enable applications to detect when previously retrieved data is incompatible with the device, the initial bytes written to pData must be a header consisting of the following members:

        OffsetSizeMeaning
        04length in bytes of the entire pipeline cache header written as a stream of bytes, with the least significant byte first
        44a VkPipelineCacheHeaderVersion value written as a stream of bytes, with the least significant byte first
        84a vendor ID equal to VkPhysicalDeviceProperties::vendorID written as a stream of bytes, with the least significant byte first
        124a device ID equal to VkPhysicalDeviceProperties::deviceID written as a stream of bytes, with the least significant byte first
        16UUID_SIZEa pipeline cache ID equal to VkPhysicalDeviceProperties::pipelineCacheUUID

        The first four bytes encode the length of the entire pipeline header, in bytes. This value includes all fields in the header including the pipeline cache version field and the size of the length field.

        The next four bytes encode the pipeline cache version. This field is interpreted as an VkPipelineCacheHeaderVersion value, and must have one of the following values:

        typedef enum VkPipelineCacheHeaderVersion {
            VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
        } VkPipelineCacheHeaderVersion;

        A consumer of the pipeline cache should use the cache version to interpret the remainder of the cache header.

        If dataSize is less than what is necessary to store this header, nothing will be written to pData and zero will be written to dataSize.

        Parameters:
        device - the logical device that owns the pipeline cache
        pipelineCache - the pipeline cache to retrieve data from
        pDataSize - a pointer to a value related to the amount of data in the pipeline cache
        pData - either NULL or a pointer to a buffer
      • vkMergePipelineCaches

        public static int vkMergePipelineCaches(VkDevice device,
                                                long dstCache,
                                                java.nio.LongBuffer pSrcCaches)

        Khronos Reference Page

        Merges pipeline cache objects.
        Note

        The details of the merge operation are implementation dependent, but implementations should merge the contents of the specified pipelines and prune duplicate entries.

        Valid Usage
        • device must be a valid VkDevice handle
        • dstCache must be a valid VkPipelineCache handle
        • pSrcCaches must be a pointer to an array of srcCacheCount valid VkPipelineCache handles
        • srcCacheCount must be greater than 0
        • dstCache must have been created, allocated or retrieved from device
        • Each element of pSrcCaches must have been created, allocated or retrieved from device
        • Each of device, dstCache and the elements of pSrcCaches must have been created, allocated or retrieved from the same VkPhysicalDevice
        • dstCache must not appear in the list of source caches
        Host Synchronization
        • Host access to dstCache must be externally synchronized
        Parameters:
        device - the logical device that owns the pipeline cache objects
        dstCache - the handle of the pipeline cache to merge results into
        pSrcCaches - an array of pipeline cache handles, which will be merged into dstCache. The previous contents of dstCache are included after the merge.
      • vkCreateGraphicsPipelines

        public static int vkCreateGraphicsPipelines(VkDevice device,
                                                    long pipelineCache,
                                                    VkGraphicsPipelineCreateInfo.Buffer pCreateInfos,
                                                    VkAllocationCallbacks pAllocator,
                                                    java.nio.LongBuffer pPipelines)

        Khronos Reference Page

        Creates graphics pipelines.

        Graphics pipelines consist of multiple shader stages, multiple fixed-function pipeline stages, and a pipeline layout.

        Valid Usage
        • device must be a valid VkDevice handle
        • If pipelineCache is not NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
        • pCreateInfos must be a pointer to an array of createInfoCount valid VkGraphicsPipelineCreateInfo structures
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pPipelines must be a pointer to an array of createInfoCount VkPipeline handles
        • createInfoCount must be greater than 0
        • If pipelineCache is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and pipelineCache that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • If the flags member of any given element of pCreateInfos contains the PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element
        Parameters:
        device - the logical device that creates the graphics pipelines
        pipelineCache - either NULL_HANDLE, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command
        pCreateInfos - an array of VkGraphicsPipelineCreateInfo structures
        pAllocator - controls host memory allocation
        pPipelines - a pointer to an array in which the resulting graphics pipeline objects are returned
      • vkCreateComputePipelines

        public static int vkCreateComputePipelines(VkDevice device,
                                                   long pipelineCache,
                                                   VkComputePipelineCreateInfo.Buffer pCreateInfos,
                                                   VkAllocationCallbacks pAllocator,
                                                   java.nio.LongBuffer pPipelines)

        Khronos Reference Page

        Creates a new compute pipeline object.

        Compute pipelines consist of a single static compute shader stage and the pipeline layout.

        The compute pipeline encapsulates a compute shader and is created by calling vkCreateComputePipelines with module and pName selecting an entry point from a shader module, where that entry point defines a valid compute shader, in the VkPipelineShaderStageCreateInfo structure contained within the VkComputePipelineCreateInfo structure.

        Valid Usage
        • device must be a valid VkDevice handle
        • If pipelineCache is not NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
        • pCreateInfos must be a pointer to an array of createInfoCount valid VkComputePipelineCreateInfo structures
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pPipelines must be a pointer to an array of createInfoCount VkPipeline handles
        • createInfoCount must be greater than 0
        • If pipelineCache is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and pipelineCache that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • If the flags member of any given element of pCreateInfos contains the PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element
        Parameters:
        device - the logical device that creates the compute pipelines
        pipelineCache - either NULL_HANDLE, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command
        pCreateInfos - an array of VkComputePipelineCreateInfo structures
        pAllocator - controls host memory allocation
        pPipelines - a pointer to an array in which the resulting compute pipeline objects are returned
      • vkDestroyPipeline

        public static void vkDestroyPipeline(VkDevice device,
                                             long pipeline,
                                             VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a graphics or compute pipeline object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If pipeline is not NULL_HANDLE, pipeline must be a valid VkPipeline handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If pipeline is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and pipeline that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to pipeline must have completed execution
        • If VkAllocationCallbacks were provided when pipeline was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when pipeline was created, pAllocator must be NULL
        Host Synchronization
        • Host access to pipeline must be externally synchronized
        Parameters:
        device - the logical device that destroys the pipeline
        pipeline - the handle of the pipeline to destroy
        pAllocator - controls host memory allocation
      • vkCreatePipelineLayout

        public static int vkCreatePipelineLayout(VkDevice device,
                                                 VkPipelineLayoutCreateInfo pCreateInfo,
                                                 VkAllocationCallbacks pAllocator,
                                                 java.nio.LongBuffer pPipelineLayout)

        Khronos Reference Page

        Creates a new pipeline layout object.

        Access to descriptor sets from a pipeline is accomplished through a pipeline layout. Zero or more descriptor set layouts and zero or more push constant ranges are combined to form a pipeline layout object which describes the complete set of resources that can be accessed by a pipeline. The pipeline layout represents a sequence of descriptor sets with each having a specific layout. This sequence of layouts is used to determine the interface between shader stages and shader resources. Each pipeline is created using a pipeline layout.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkPipelineLayoutCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pPipelineLayout must be a pointer to a VkPipelineLayout handle

        Once created, pipeline layouts are used as part of pipeline creation, as part of binding descriptor sets, and as part of setting push constants. Pipeline creation accepts a pipeline layout as input, and the layout may be used to map (set, binding, arrayElement) tuples to hardware resources or memory locations within a descriptor set. The assignment of hardware resources depends only on the bindings defined in the descriptor sets that comprise the pipeline layout, and not on any shader source.

        All resource variables statically used in all shaders in a pipeline must be declared with a (set, binding, arrayElement) that exists in the corresponding descriptor set layout and is of an appropriate descriptor type and includes the set of shader stages it is used by in stageFlags. The pipeline layout can include entries that are not used by a particular pipeline, or that are dead-code eliminated from any of the shaders. The pipeline layout allows the application to provide a consistent set of bindings across multiple pipeline compiles, which enables those pipelines to be compiled in a way that the implementation may cheaply switch pipelines without reprogramming the bindings.

        Similarly, the push constant block declared in each shader (if present) must only place variables at offsets that are each included in a push constant range with stageFlags including the bit corresponding to the shader stage that uses it. The pipeline layout can include ranges or portions of ranges that are not used by a particular pipeline, or for which the variables have been dead-code eliminated from any of the shaders.

        There is a limit on the total number of resources of each type that can be included in bindings in all descriptor set layouts in a pipeline layout as shown in the table below. The “Total Resources Available” column gives the limit on the number of each type of resource that can be included in bindings in all descriptor sets in the pipeline layout. Some resource types count against multiple limits. Additionally, there are limits on the total number of each type of resource that can be used in any pipeline stage.

        Total Resources AvailableResource Types
        maxDescriptorSetSamplerssampler
        combined image sampler
        maxDescriptorSetSampledImagessampled image
        combined image sampler
        uniform texel buffer
        maxDescriptorSetStorageImagesstorage image
        storage texel buffer
        maxDescriptorSetUniformBuffersuniform buffer
        uniform buffer dynamic
        maxDescriptorSetUniformBuffersDynamicuniform buffer dynamic
        maxDescriptorSetStorageBuffersstorage buffer
        storage buffer dynamic
        maxDescriptorSetStorageBuffersDynamicstorage buffer dynamic
        maxDescriptorSetInputAttachmentsinput attachment
        Pipeline Layout Compatibility

        Two pipeline layouts are defined to be “compatible for push constants” if they were created with identical push constant ranges. Two pipeline layouts are defined to be “compatible for set N” if they were created with matching (the same, or identically defined) descriptor set layouts for sets zero through N, and if they were created with identical push constant ranges.

        When binding a descriptor set to set number N, if the previously bound descriptor sets for sets zero through N-1 were all bound using compatible pipeline layouts, then performing this binding does not disturb any of the lower numbered sets. If, additionally, the previous bound descriptor set for set N was bound using a pipeline layout compatible for set N, then the bindings in sets numbered greater than N are also not disturbed.

        Similarly, when binding a pipeline, the pipeline can correctly access any previously bound descriptor sets which were bound with compatible pipeline layouts, as long as all lower numbered sets were also bound with compatible layouts.

        Layout compatibility means that descriptor sets can be bound to a command buffer for use by any pipeline created with a compatible pipeline layout, and without having bound a particular pipeline first. It also means that descriptor sets can remain valid across a pipeline change, and the same resources will be accessible to the newly bound pipeline.

        Implementor’s Note

        A consequence of layout compatibility is that when the implementation compiles a pipeline layout and assigns hardware units to resources, the mechanism to assign hardware units for set N should only be a function of sets [0..N].

        Note

        Place the least frequently changing descriptor sets near the start of the pipeline layout, and place the descriptor sets representing the most frequently changing resources near the end. When pipelines are switched, only the descriptor set bindings that have been invalidated will need to be updated and the remainder of the descriptor set bindings will remain in place.

        The maximum number of descriptor sets that can be bound to a pipeline layout is queried from physical device properties (see VkPhysicalDeviceLimits::maxBoundDescriptorSets).

        Parameters:
        device - the logical device that creates the pipeline layout
        pCreateInfo - a pointer to an instance of the VkPipelineLayoutCreateInfo structure specifying the state of the pipeline layout object
        pAllocator - controls host memory allocation
        pPipelineLayout - points to a VkPipelineLayout handle in which the resulting pipeline layout object is returned
      • vkDestroyPipelineLayout

        public static void vkDestroyPipelineLayout(VkDevice device,
                                                   long pipelineLayout,
                                                   VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a pipeline layout object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If pipelineLayout is not NULL_HANDLE, pipelineLayout must be a valid VkPipelineLayout handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If pipelineLayout is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and pipelineLayout that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • If VkAllocationCallbacks were provided when pipelineLayout was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when pipelineLayout was created, pAllocator must be NULL
        Host Synchronization
        • Host access to pipelineLayout must be externally synchronized
        Parameters:
        device - the logical device that destroys the pipeline layout
        pipelineLayout - the pipeline layout to destroy
        pAllocator - controls host memory allocation
      • vkCreateSampler

        public static int vkCreateSampler(VkDevice device,
                                          VkSamplerCreateInfo pCreateInfo,
                                          VkAllocationCallbacks pAllocator,
                                          java.nio.LongBuffer pSampler)

        Khronos Reference Page

        Creates a new sampler object.

        VkSampler objects encapsulate the state of an image sampler which is used by the implementation to read image data and apply filtering and other transformations for the shader.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkSamplerCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pSampler must be a pointer to a VkSampler handle
        Parameters:
        device - the logical device that creates the sampler
        pCreateInfo - a pointer to an instance of the VkSamplerCreateInfo structure specifying the state of the sampler object
        pAllocator - controls host memory allocation
        pSampler - points to a VkSampler handle in which the resulting sampler object is returned
      • vkDestroySampler

        public static void vkDestroySampler(VkDevice device,
                                            long sampler,
                                            VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a sampler object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If sampler is not NULL_HANDLE, sampler must be a valid VkSampler handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If sampler is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and sampler that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to sampler must have completed execution
        • If VkAllocationCallbacks were provided when sampler was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when sampler was created, pAllocator must be NULL
        Host Synchronization
        • Host access to sampler must be externally synchronized
        Parameters:
        device - the logical device that destroys the sampler
        sampler - the sampler to destroy
        pAllocator - controls host memory allocation
      • vkCreateDescriptorSetLayout

        public static int vkCreateDescriptorSetLayout(VkDevice device,
                                                      VkDescriptorSetLayoutCreateInfo pCreateInfo,
                                                      VkAllocationCallbacks pAllocator,
                                                      java.nio.LongBuffer pSetLayout)

        Khronos Reference Page

        Creates a new descriptor set layout object.

        A descriptor set layout object is defined by an array of zero or more descriptor bindings. Each individual descriptor binding is specified by a descriptor type, a count (array size) of the number of descriptors in the binding, a set of shader stages that can access the binding, and (if using immutable samplers) an array of sampler descriptors.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkDescriptorSetLayoutCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pSetLayout must be a pointer to a VkDescriptorSetLayout handle
        Parameters:
        device - the logical device that creates the descriptor set layout
        pCreateInfo - a pointer to an instance of the VkDescriptorSetLayoutCreateInfo structure specifying the state of the descriptor set layout object
        pAllocator - controls host memory allocation
        pSetLayout - points to a VkDescriptorSetLayout handle in which the resulting descriptor set layout object is returned
      • vkDestroyDescriptorSetLayout

        public static void vkDestroyDescriptorSetLayout(VkDevice device,
                                                        long descriptorSetLayout,
                                                        VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a descriptor set layout object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If descriptorSetLayout is not NULL_HANDLE, descriptorSetLayout must be a valid VkDescriptorSetLayout handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If descriptorSetLayout is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and descriptorSetLayout that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • If VkAllocationCallbacks were provided when descriptorSetLayout was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when descriptorSetLayout was created, pAllocator must be NULL
        Host Synchronization
        • Host access to descriptorSetLayout must be externally synchronized
        Parameters:
        device - the logical device that destroys the descriptor set layout
        descriptorSetLayout - the descriptor set layout to destroy
        pAllocator - controls host memory allocation
      • vkCreateDescriptorPool

        public static int vkCreateDescriptorPool(VkDevice device,
                                                 VkDescriptorPoolCreateInfo pCreateInfo,
                                                 VkAllocationCallbacks pAllocator,
                                                 java.nio.LongBuffer pDescriptorPool)

        Khronos Reference Page

        Creates a descriptor pool object.

        Descriptor sets are allocated from descriptor pool objects. A descriptor pool maintains a pool of descriptors, from which sets are allocated. Descriptor pools are externally synchronized, meaning that the application must not allocate and/or free descriptor sets from the same pool in multiple threads simultaneously.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkDescriptorPoolCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pDescriptorPool must be a pointer to a VkDescriptorPool handle
        Parameters:
        device - the logical device that creates the descriptor pool
        pCreateInfo - a pointer to an instance of the VkDescriptorPoolCreateInfo structure specifying the state of the descriptor pool object
        pAllocator - controls host memory allocation
        pDescriptorPool - points to a VkDescriptorPool handle in which the resulting descriptor pool object is returned
      • vkDestroyDescriptorPool

        public static void vkDestroyDescriptorPool(VkDevice device,
                                                   long descriptorPool,
                                                   VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a descriptor pool object.

        When a pool is destroyed, all descriptor sets allocated from the pool are implicitly freed and become invalid. Descriptor sets allocated from a given pool do not need to be freed before destroying that descriptor pool.

        Valid Usage
        • device must be a valid VkDevice handle
        • If descriptorPool is not NULL_HANDLE, descriptorPool must be a valid VkDescriptorPool handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If descriptorPool is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and descriptorPool that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to descriptorPool (via any allocated descriptor sets) must have completed execution
        • If VkAllocationCallbacks were provided when descriptorPool was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when descriptorPool was created, pAllocator must be NULL
        Host Synchronization
        • Host access to descriptorPool must be externally synchronized
        Parameters:
        device - the logical device that destroys the descriptor pool
        descriptorPool - the descriptor pool to destroy
        pAllocator - controls host memory allocation
      • vkResetDescriptorPool

        public static int vkResetDescriptorPool(VkDevice device,
                                                long descriptorPool,
                                                int flags)

        Khronos Reference Page

        Resets a descriptor pool object.

        Rather than freeing individual descriptor sets, all descriptor sets allocated from a given pool can be returned to the pool by calling this function.

        Resetting a descriptor pool recycles all of the resources from all of the descriptor sets allocated from the descriptor pool back to the descriptor pool, and the descriptor sets are implicitly freed.

        Valid Usage
        • device must be a valid VkDevice handle
        • descriptorPool must be a valid VkDescriptorPool handle
        • flags must be 0
        • descriptorPool must have been created, allocated or retrieved from device
        • Each of device and descriptorPool must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All uses of descriptorPool (via any allocated descriptor sets) must have completed execution
        Host Synchronization
        • Host access to descriptorPool must be externally synchronized
        • Host access to any VkDescriptorSet objects allocated from descriptorPool must be externally synchronized
        Parameters:
        device - the logical device that owns the descriptor pool
        descriptorPool - the descriptor pool to be reset
        flags - is currently unused and must be zero
      • vkAllocateDescriptorSets

        public static int vkAllocateDescriptorSets(VkDevice device,
                                                   VkDescriptorSetAllocateInfo pAllocateInfo,
                                                   java.nio.LongBuffer pDescriptorSets)

        Khronos Reference Page

        Allocates descriptor sets from a descriptor pool.

        When a descriptor set is allocated, the initial state is largely uninitialized and all descriptors are undefined. However, the descriptor set can be bound in a command buffer without causing errors or exceptions. All entries that are statically used by a pipeline in a drawing or dispatching command must have been populated before the descriptor set is bound for use by that command. Entries that are not statically used by a pipeline can have uninitialized descriptors or descriptors of resources that have been destroyed, and executing a draw or dispatch with such a descriptor set bound does not cause undefined behavior. This means applications need not populate unused entries with dummy descriptors.

        Valid Usage
        • device must be a valid VkDevice handle
        • pAllocateInfo must be a pointer to a valid VkDescriptorSetAllocateInfo structure
        • pDescriptorSets must be a pointer to an array of pAllocateInfo->descriptorSetCount VkDescriptorSet handles
        Host Synchronization
        • Host access to pAllocateInfo->descriptorPool must be externally synchronized
        Parameters:
        device - the logical device that owns the descriptor pool
        pAllocateInfo - a pointer to an instance of the VkDescriptorSetAllocateInfo structure describing parameters of the allocation
        pDescriptorSets - a pointer to an array of VkDescriptorSet handles in which the resulting descriptor set objects are returned. The array must be at least the length specified by the descriptorSetCount member of pAllocateInfo.
      • vkFreeDescriptorSets

        public static int vkFreeDescriptorSets(VkDevice device,
                                               long descriptorPool,
                                               java.nio.LongBuffer pDescriptorSets)

        Khronos Reference Page

        Frees one or more descriptor sets.
        Valid Usage
        • device must be a valid VkDevice handle
        • descriptorPool must be a valid VkDescriptorPool handle
        • descriptorSetCount must be greater than 0
        • descriptorPool must have been created, allocated or retrieved from device
        • Each element of pDescriptorSets that is a valid handle must have been created, allocated or retrieved from descriptorPool
        • Each of device, descriptorPool and the elements of pDescriptorSets that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to any element of pDescriptorSets must have completed execution
        • pDescriptorSets must be a pointer to an array of descriptorSetCount VkDescriptorSet handles, each element of which must either be a valid handle or NULL_HANDLE
        • descriptorPool must have been created with the DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT flag
        Host Synchronization
        • Host access to descriptorPool must be externally synchronized
        • Host access to each member of pDescriptorSets must be externally synchronized
        Parameters:
        device - the logical device that owns the descriptor pool
        descriptorPool - the descriptor pool from which the descriptor sets were allocated
        pDescriptorSets - an array of handles to VkDescriptorSet objects. All elements of pDescriptorSets must have been allocated from descriptorPool.
      • vkFreeDescriptorSets

        public static int vkFreeDescriptorSets(VkDevice device,
                                               long descriptorPool,
                                               long pDescriptorSet)

        Khronos Reference Page

        Frees one or more descriptor sets.
        Valid Usage
        • device must be a valid VkDevice handle
        • descriptorPool must be a valid VkDescriptorPool handle
        • descriptorSetCount must be greater than 0
        • descriptorPool must have been created, allocated or retrieved from device
        • Each element of pDescriptorSets that is a valid handle must have been created, allocated or retrieved from descriptorPool
        • Each of device, descriptorPool and the elements of pDescriptorSets that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to any element of pDescriptorSets must have completed execution
        • pDescriptorSets must be a pointer to an array of descriptorSetCount VkDescriptorSet handles, each element of which must either be a valid handle or NULL_HANDLE
        • descriptorPool must have been created with the DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT flag
        Host Synchronization
        • Host access to descriptorPool must be externally synchronized
        • Host access to each member of pDescriptorSets must be externally synchronized
        Parameters:
        device - the logical device that owns the descriptor pool
        descriptorPool - the descriptor pool from which the descriptor sets were allocated
      • vkUpdateDescriptorSets

        public static void vkUpdateDescriptorSets(VkDevice device,
                                                  VkWriteDescriptorSet.Buffer pDescriptorWrites,
                                                  VkCopyDescriptorSet.Buffer pDescriptorCopies)

        Khronos Reference Page

        Updates the contents of a descriptor set object.

        Once allocated, descriptor sets can be updated with a combination of write and copy operations.

        Valid Usage
        • device must be a valid VkDevice handle
        • If descriptorWriteCount is not 0, pDescriptorWrites must be a pointer to an array of descriptorWriteCount valid VkWriteDescriptorSet structures
        • If descriptorCopyCount is not 0, pDescriptorCopies must be a pointer to an array of descriptorCopyCount valid VkCopyDescriptorSet structures
        Host Synchronization
        • Host access to pDescriptorWrites[].dstSet must be externally synchronized
        • Host access to pDescriptorCopies[].dstSet must be externally synchronized
        Parameters:
        device - the logical device that updates the descriptor sets
        pDescriptorWrites - a pointer to an array of VkWriteDescriptorSet structures describing the descriptor sets to write to
        pDescriptorCopies - a pointer to an array of VkCopyDescriptorSet structures describing the descriptor sets to copy between
      • vkCreateFramebuffer

        public static int vkCreateFramebuffer(VkDevice device,
                                              VkFramebufferCreateInfo pCreateInfo,
                                              VkAllocationCallbacks pAllocator,
                                              java.nio.LongBuffer pFramebuffer)

        Khronos Reference Page

        Creates a new framebuffer object.

        Render passes operate in conjunction with framebuffers, which represent a collection of specific memory attachments that a render pass instance uses.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkFramebufferCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pFramebuffer must be a pointer to a VkFramebuffer handle
        Parameters:
        device - the logical device that creates the framebuffer
        pCreateInfo - points to a VkFramebufferCreateInfo structure which describes additional information about framebuffer creation
        pAllocator - controls host memory allocation
        pFramebuffer - points to a VkFramebuffer handle in which the resulting framebuffer object is returned
      • vkDestroyFramebuffer

        public static void vkDestroyFramebuffer(VkDevice device,
                                                long framebuffer,
                                                VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a framebuffer object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If framebuffer is not NULL_HANDLE, framebuffer must be a valid VkFramebuffer handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If framebuffer is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and framebuffer that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to framebuffer must have completed execution
        • If VkAllocationCallbacks were provided when framebuffer was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when framebuffer was created, pAllocator must be NULL
        Host Synchronization
        • Host access to framebuffer must be externally synchronized
        Parameters:
        device - the logical device that destroys the framebuffer
        framebuffer - the handle of the framebuffer to destroy
        pAllocator - controls host memory allocation
      • vkCreateRenderPass

        public static int vkCreateRenderPass(VkDevice device,
                                             VkRenderPassCreateInfo pCreateInfo,
                                             VkAllocationCallbacks pAllocator,
                                             java.nio.LongBuffer pRenderPass)

        Khronos Reference Page

        Creates a new render pass object.
        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkRenderPassCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pRenderPass must be a pointer to a VkRenderPass handle
        Parameters:
        device - the logical device that creates the render pass
        pCreateInfo - a pointer to an instance of the VkRenderPassCreateInfo structure that describes the parameters of the render pass
        pAllocator - controls host memory allocation
        pRenderPass - points to a VkRenderPass handle in which the resulting render pass object is returned
      • vkDestroyRenderPass

        public static void vkDestroyRenderPass(VkDevice device,
                                               long renderPass,
                                               VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a render pass object.
        Valid Usage
        • device must be a valid VkDevice handle
        • If renderPass is not NULL_HANDLE, renderPass must be a valid VkRenderPass handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If renderPass is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and renderPass that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All submitted commands that refer to renderPass must have completed execution
        • If VkAllocationCallbacks were provided when renderPass was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when renderPass was created, pAllocator must be NULL
        Host Synchronization
        • Host access to renderPass must be externally synchronized
        Parameters:
        device - the logical device that destroys the render pass
        renderPass - the handle of the render pass to destroy
        pAllocator - controls host memory allocation
      • vkGetRenderAreaGranularity

        public static void vkGetRenderAreaGranularity(VkDevice device,
                                                      long renderPass,
                                                      VkExtent2D pGranularity)

        Khronos Reference Page

        Queries the granularity for optimal render area.

        The conditions leading to an optimal renderArea are:

        • the offset.x member in renderArea is a multiple of the width member of the returned VkExtent2D (the horizontal granularity).
        • the offset.y member in renderArea is a multiple of the height of the returned VkExtent2D (the vertical granularity).
        • either the offset.width member in renderArea is a multiple of the horizontal granularity or offset.x+offset.width is equal to the width of the framebuffer in the VkRenderPassBeginInfo.
        • either the offset.height member in renderArea is a multiple of the vertical granularity or offset.y+offset.height is equal to the height of the framebuffer in the VkRenderPassBeginInfo.
        Valid Usage
        • device must be a valid VkDevice handle
        • renderPass must be a valid VkRenderPass handle
        • pGranularity must be a pointer to a VkExtent2D structure
        • renderPass must have been created, allocated or retrieved from device
        • Each of device and renderPass must have been created, allocated or retrieved from the same VkPhysicalDevice
        Parameters:
        device - the logical device that owns the render pass
        renderPass - a handle to a render pass
        pGranularity - points to a VkExtent2D structure in which the granularity is returned
      • vkCreateCommandPool

        public static int vkCreateCommandPool(VkDevice device,
                                              VkCommandPoolCreateInfo pCreateInfo,
                                              VkAllocationCallbacks pAllocator,
                                              java.nio.LongBuffer pCommandPool)

        Khronos Reference Page

        Creates a new command pool object.

        Command pools are opaque objects that command buffer memory is allocated from, and which allow the implementation to amortize the cost of resource creation across multiple command buffers. Command pools are application-synchronized, meaning that a command pool must not be used concurrently in multiple threads. That includes use via recording commands on any command buffers allocated from the pool, as well as operations that allocate, free, and reset command buffers or the pool itself.

        Valid Usage
        • device must be a valid VkDevice handle
        • pCreateInfo must be a pointer to a valid VkCommandPoolCreateInfo structure
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • pCommandPool must be a pointer to a VkCommandPool handle
        Parameters:
        device - the logical device that creates the command pool
        pCreateInfo - contains information used to create the command pool
        pAllocator - controls host memory allocation
        pCommandPool - points to an VkCommandPool handle in which the created pool is returned
      • vkDestroyCommandPool

        public static void vkDestroyCommandPool(VkDevice device,
                                                long commandPool,
                                                VkAllocationCallbacks pAllocator)

        Khronos Reference Page

        Destroys a command pool object.

        When a pool is destroyed, all command buffers allocated from the pool are implicitly freed and become invalid. Command buffers allocated from a given pool do not need to be freed before destroying that command pool.

        Valid Usage
        • device must be a valid VkDevice handle
        • If commandPool is not NULL_HANDLE, commandPool must be a valid VkCommandPool handle
        • If pAllocator is not NULL, pAllocator must be a pointer to a valid VkAllocationCallbacks structure
        • If commandPool is a valid handle, it must have been created, allocated or retrieved from device
        • Each of device and commandPool that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All VkCommandBuffer objects allocated from commandPool must not be pending execution
        • If VkAllocationCallbacks were provided when commandPool was created, a compatible set of callbacks must be provided here
        • If no VkAllocationCallbacks were provided when commandPool was created, pAllocator must be NULL
        Host Synchronization
        • Host access to commandPool must be externally synchronized
        Parameters:
        device - the logical device that destroys the command pool
        commandPool - the handle of the command pool to destroy
        pAllocator - controls host memory allocation
      • vkResetCommandPool

        public static int vkResetCommandPool(VkDevice device,
                                             long commandPool,
                                             int flags)

        Khronos Reference Page

        Resets a command pool.
        Valid Usage
        • device must be a valid VkDevice handle
        • commandPool must be a valid VkCommandPool handle
        • flags must be a valid combination of VkCommandPoolResetFlagBits values
        • commandPool must have been created, allocated or retrieved from device
        • Each of device and commandPool must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All VkCommandBuffer objects allocated from commandPool must not currently be pending execution
        Host Synchronization
        • Host access to commandPool must be externally synchronized
        Parameters:
        device - the logical device that owns the command pool
        commandPool - the command pool to reset
        flags - contains additional flags controlling the behavior of the reset. One or more of:
        COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
      • vkAllocateCommandBuffers

        public static int vkAllocateCommandBuffers(VkDevice device,
                                                   VkCommandBufferAllocateInfo pAllocateInfo,
                                                   PointerBuffer pCommandBuffers)

        Khronos Reference Page

        Allocates command buffers.
        Valid Usage
        • device must be a valid VkDevice handle
        • pAllocateInfo must be a pointer to a valid VkCommandBufferAllocateInfo structure
        • pCommandBuffers must be a pointer to an array of pAllocateInfo->commandBufferCount VkCommandBuffer handles
        Host Synchronization
        • Host access to pAllocateInfo->commandPool must be externally synchronized
        Parameters:
        device - the logical device that owns the command pool
        pAllocateInfo - an instance of the VkCommandBufferAllocateInfo structure which defines additional information about creating the pool
        pCommandBuffers - points to an array in which the allocated command buffers are returned. Each allocated command buffer begins in the initial state.
      • vkFreeCommandBuffers

        public static void vkFreeCommandBuffers(VkDevice device,
                                                long commandPool,
                                                PointerBuffer pCommandBuffers)

        Khronos Reference Page

        Frees command buffers.
        Valid Usage
        • device must be a valid VkDevice handle
        • commandPool must be a valid VkCommandPool handle
        • commandBufferCount must be greater than 0
        • commandPool must have been created, allocated or retrieved from device
        • Each element of pCommandBuffers that is a valid handle must have been created, allocated or retrieved from commandPool
        • Each of device, commandPool and the elements of pCommandBuffers that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All elements of pCommandBuffers must not be pending execution
        • pCommandBuffers must be a pointer to an array of commandBufferCount VkCommandBuffer handles, each element of which must either be a valid handle or NULL_HANDLE
        Host Synchronization
        • Host access to commandPool must be externally synchronized
        • Host access to each member of pCommandBuffers must be externally synchronized
        Parameters:
        device - the logical device that owns the command pool
        commandPool - the handle of the command pool that the command buffers were allocated from
        pCommandBuffers - an array of handles of command buffers to free
      • vkFreeCommandBuffers

        public static void vkFreeCommandBuffers(VkDevice device,
                                                long commandPool,
                                                VkCommandBuffer pCommandBuffer)

        Khronos Reference Page

        Frees command buffers.
        Valid Usage
        • device must be a valid VkDevice handle
        • commandPool must be a valid VkCommandPool handle
        • commandBufferCount must be greater than 0
        • commandPool must have been created, allocated or retrieved from device
        • Each element of pCommandBuffers that is a valid handle must have been created, allocated or retrieved from commandPool
        • Each of device, commandPool and the elements of pCommandBuffers that are valid handles must have been created, allocated or retrieved from the same VkPhysicalDevice
        • All elements of pCommandBuffers must not be pending execution
        • pCommandBuffers must be a pointer to an array of commandBufferCount VkCommandBuffer handles, each element of which must either be a valid handle or NULL_HANDLE
        Host Synchronization
        • Host access to commandPool must be externally synchronized
        • Host access to each member of pCommandBuffers must be externally synchronized
        Parameters:
        device - the logical device that owns the command pool
        commandPool - the handle of the command pool that the command buffers were allocated from
      • vkBeginCommandBuffer

        public static int vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
                                               VkCommandBufferBeginInfo pBeginInfo)

        Khronos Reference Page

        Starts recording a command buffer.
        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • pBeginInfo must be a pointer to a valid VkCommandBufferBeginInfo structure
        • commandBuffer must not be in the recording state
        • commandBuffer must not currently be pending execution
        • If commandBuffer was allocated from a VkCommandPool which did not have the COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, commandBuffer must be in the initial state.
        • If commandBuffer is a secondary command buffer, the pInheritanceInfo member of pBeginInfo must be a valid VkCommandBufferInheritanceInfo structure
        • If commandBuffer is a secondary command buffer and either the occlusionQueryEnable member of the pInheritanceInfo member of pBeginInfo is FALSE, or the precise occlusion queries feature is not enabled, the queryFlags member of the pInheritanceInfo member pBeginInfo must not contain QUERY_CONTROL_PRECISE_BIT
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized

        A primary command buffer is considered to be pending execution from the time it is submitted via QueueSubmit until that submission completes.

        A secondary command buffer is considered to be pending execution from the time its execution is recorded into a primary buffer (via CmdExecuteCommands) until the final time that primary buffer’s submission to a queue completes. If, after the primary buffer completes, the secondary command buffer is recorded to execute on a different primary buffer, the first primary buffer must not be resubmitted until after it is reset with ResetCommandBuffer unless the secondary command buffer was recorded with COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT.

        If COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT is not set on a secondary command buffer, that command buffer must not be used more than once in a given primary command buffer. Furthermore, if a secondary command buffer without COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set is recorded to execute in a primary command buffer with COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set, the primary command buffer must not be pending execution more than once at a time.

        Note

        On some implementations, not using the COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT bit enables command buffers to be patched in-place if needed, rather than creating a copy of the command buffer.

        If a command buffer is in the executable state and the command buffer was allocated from a command pool with the COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, then vkBeginCommandBuffer implicitly resets the command buffer, behaving as if ResetCommandBuffer had been called with COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT not set. It then puts the command buffer in the recording state.

        Once recording starts, an application records a sequence of commands (vkCmd*) to set state in the command buffer, draw, dispatch, and other commands.

        Parameters:
        commandBuffer - the handle of the command buffer which is to be put in the recording state
        pBeginInfo - an instance of the VkCommandBufferBeginInfo structure, which defines additional information about how the command buffer begins recording
      • vkEndCommandBuffer

        public static int vkEndCommandBuffer(VkCommandBuffer commandBuffer)

        Khronos Reference Page

        Completes recording a command buffer.

        If there was an error during recording, the application will be notified by an unsuccessful return code returned by vkEndCommandBuffer. If the application wishes to further use the command buffer, the command buffer must be reset.

        When a command buffer is in the executable state, it can be submitted to a queue for execution.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • commandBuffer must be in the recording state
        • EndCommandBuffer must not be called inside a render pass instance
        • All queries made active during the recording of commandBuffer must have been made inactive
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer to complete recording. The command buffer must have been in the recording state, and is moved to the executable state.
      • vkResetCommandBuffer

        public static int vkResetCommandBuffer(VkCommandBuffer commandBuffer,
                                               int flags)

        Khronos Reference Page

        Resets a command buffer.

        If flags includes COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT, then most or all memory resources currently owned by the command buffer should be returned to the parent command pool. If this flag is not set, then the command buffer may hold onto memory resources and reuse them when recording commands.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • flags must be a valid combination of VkCommandBufferResetFlagBits values
        • commandBuffer must not currently be pending execution
        • commandBuffer must have been allocated from a pool that was created with the COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer to reset. The command buffer can be in any state, and is put in the initial state.
        flags - is of type VkCommandBufferResetFlags. One or more of:
        COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
      • vkCmdBindPipeline

        public static void vkCmdBindPipeline(VkCommandBuffer commandBuffer,
                                             int pipelineBindPoint,
                                             long pipeline)

        Khronos Reference Page

        Binds a pipeline object to a command buffer.

        Once bound, a pipeline binding affects subsequent graphics or compute commands in the command buffer until a different pipeline is bound to the bind point. The pipeline bound to PIPELINE_BIND_POINT_COMPUTE controls the behavior of CmdDispatch and CmdDispatchIndirect. The pipeline bound to PIPELINE_BIND_POINT_GRAPHICS controls the behavior of CmdDraw, CmdDrawIndexed, CmdDrawIndirect, and CmdDrawIndexedIndirect. No other commands are affected by the pipeline state.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • pipelineBindPoint must be a valid VkPipelineBindPoint value
        • pipeline must be a valid VkPipeline handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
        • Each of commandBuffer and pipeline must have been created, allocated or retrieved from the same VkDevice
        • If pipelineBindPoint is PIPELINE_BIND_POINT_COMPUTE, the VkCommandPool that commandBuffer was allocated from must support compute operations
        • If pipelineBindPoint is PIPELINE_BIND_POINT_GRAPHICS, the VkCommandPool that commandBuffer was allocated from must support graphics operations
        • If pipelineBindPoint is PIPELINE_BIND_POINT_COMPUTE, pipeline must be a compute pipeline
        • If pipelineBindPoint is PIPELINE_BIND_POINT_GRAPHICS, pipeline must be a graphics pipeline
        • If the variable multisample rate feature is not supported, pipeline is a graphics pipeline, the current subpass has no attachments, and this is not the first call to this function with a graphics pipeline after transitioning to the current subpass, then the sample count specified by this pipeline must match that set in the previous pipeline
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer that the pipeline will be bound to
        pipelineBindPoint - the bind point. There are separate bind points for each of graphics and compute, so binding one does not disturb the other. One of:
        PIPELINE_BIND_POINT_GRAPHICSPIPELINE_BIND_POINT_COMPUTE
        pipeline - the pipeline to be bound
      • vkCmdSetViewport

        public static void vkCmdSetViewport(VkCommandBuffer commandBuffer,
                                            int firstViewport,
                                            VkViewport.Buffer pViewports)

        Khronos Reference Page

        Sets the viewport on a command buffer.

        If the bound pipeline state object was not created with the DYNAMIC_STATE_VIEWPORT dynamic state enabled, viewport transformation parameters are specified using the pViewports member of VkPipelineViewportStateCreateInfo in the pipeline state object. If the pipeline state object was created with the DYNAMIC_STATE_VIEWPORT dynamic state enabled, the viewport transformation parameters are dynamically set and changed with this command.

        The viewport parameters taken from element i of pViewports replace the current state for the viewport index firstViewport + i, for i in [0,viewportCount).

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • pViewports must be a pointer to an array of viewportCount valid VkViewport structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • viewportCount must be greater than 0
        • firstViewport must be less than VkPhysicalDeviceLimits::maxViewports
        • The sum of firstViewport and viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        firstViewport - the index of the first viewport whose parameters are updated by the command
        pViewports - a pointer to an array of VkViewport structures specifying viewport parameters
      • vkCmdSetScissor

        public static void vkCmdSetScissor(VkCommandBuffer commandBuffer,
                                           int firstScissor,
                                           VkRect2D.Buffer pScissors)

        Khronos Reference Page

        Sets the dynamic scissor rectangles on a command buffer.

        The scissor test determines if a fragment’s framebuffer coordinates (xf,yf) lie within the scissor rectangle corresponding to the viewport index used by the primitive that generated the fragment. If the pipeline state object is created without DYNAMIC_STATE_SCISSOR enabled then the scissor rectangles are set by the VkPipelineViewportStateCreateInfo state of the pipeline state object. Otherwise, use this command to dynamically set the scissor rectangles.

        The scissor rectangles taken from element i of pScissors replace the current state for the scissor index firstScissor + i, for i in [0,scissorCount).

        Each scissor rectangle is described by a VkRect2D structure, with the offset.x and offset.y values determining the upper left corner of the scissor rectangle, and the extent.width and extent.height values determining the size in pixels.

        If offset.x ≤ xf < offset.x + extent.width and offset.y ≤ yf < offset.y + extent.height for the selected scissor rectangle, then the scissor test passes. Otherwise, the test fails and the fragment is discarded. For points, lines, and polygons, the scissor rectangle for a primitive is selected in the same manner as the viewport. The scissor rectangles only apply to drawing commands, not to other commands like clears or copies.

        It is legal for offset.x + extent.width or offset.y + extent.height to exceed the dimensions of the framebuffer - the scissor test still applies as defined above. Rasterization does not produce fragments outside of the framebuffer, so such fragments never have the scissor test performed on them.

        The scissor test is always performed. Applications can effectively disable the scissor test by specifying a scissor rectangle that encompasses the entire framebuffer.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • pScissors must be a pointer to an array of scissorCount VkRect2D structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • scissorCount must be greater than 0
        • firstScissor must be less than VkPhysicalDeviceLimits::maxViewports
        • The sum of firstScissor and scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
        • The x and y members of offset must be greater than or equal to 0
        • Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow
        • Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        firstScissor - the index of the first scissor whose state is updated by the command
        pScissors - a pointer to an array of VkRect2D structures defining scissor rectangles
      • vkCmdSetLineWidth

        public static void vkCmdSetLineWidth(VkCommandBuffer commandBuffer,
                                             float lineWidth)

        Khronos Reference Page

        Sets the dynamic line width state.

        A line is drawn by generating a set of fragments overlapping a rectangle centered on the line segment. Each line segment has an associated width that controls the width of that rectangle.

        The line width is set by the lineWidth property of VkPipelineRasterizationStateCreateInfo in the currently active pipeline if the pipeline was not created with DYNAMIC_STATE_LINE_WIDTH enabled. Otherwise, the line width is set by calling vkCmdSetLineWidth.

        Not all line widths need be supported for line segment rasterization, but width 1.0 antialiased segments must be provided. The range and gradations are obtained from the lineWidthRange and lineWidthGranularity members of VkPhysicalDeviceLimits. If, for instance, the size range is from 0.1 to 2.0 and the gradation size is 0.1, then the size 0.1, 0.2, …, 1.9, 2.0 are supported. Additional line widths may also be supported. There is no requirement that these widths be equally spaced. If an unsupported width is requested, the nearest supported width is used instead.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • If the wide lines feature is not enabled, lineWidth must be 1.0
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        lineWidth - the width of rasterized line segments
      • vkCmdSetDepthBias

        public static void vkCmdSetDepthBias(VkCommandBuffer commandBuffer,
                                             float depthBiasConstantFactor,
                                             float depthBiasClamp,
                                             float depthBiasSlopeFactor)

        Khronos Reference Page

        Sets the depth bias dynamic state.

        The depth values of all fragments generated by the rasterization of a polygon can be offset by a single value that is computed for that polygon. This behavior is controlled by the depthBiasEnable, depthBiasConstantFactor, depthBiasClamp, and depthBiasSlopeFactor members of VkPipelineRasterizationStateCreateInfo, or by the corresponding parameters to the vkCmdSetDepthBias command if depth bias state is dynamic.

        If depthBiasEnable is FALSE, no depth bias is applied and the fragment’s depth values are unchanged.

        depthBiasSlopeFactor scales the maximum depth slope of the polygon, and depthBiasConstantFactor scales an implementation-dependent constant that relates to the usable resolution of the depth buffer. The resulting values are summed to produce the depth bias value which is then clamped to a minimum or maximum value specified by depthBiasClamp. depthBiasSlopeFactor, depthBiasConstantFactor, and depthBiasClamp can each be positive, negative, or zero.

        The maximum depth slope mm of a triangle is

                    m = sqrt((∂zf / ∂xf)2 + (∂zf / ∂yf)2)

        where (xf,yf,zf) is a point on the triangle. m may be approximated as

                    m = max(abs(∂zf / ∂xf), abs(∂zf / ∂yf))

        The minimum resolvable difference r is an implementation-dependent parameter that depends on the depth buffer representation. It is the smallest difference in framebuffer coordinate z values that is guaranteed to remain distinct throughout polygon rasterization and in the depth buffer. All pairs of fragments generated by the rasterization of two polygons with otherwise identical vertices, but zf values that differ by r, will have distinct depth values.

        For fixed-point depth buffer representations, r is constant throughout the range of the entire depth buffer. For floating-point depth buffers, there is no single minimum resolvable difference. In this case, the minimum resolvable difference for a given polygon is dependent on the maximum exponent, e, in the range of z values spanned by the primitive. If n is the number of bits in the floating-point mantissa, the minimum resolvable difference, r, for the given primitive is defined as

                    r = 2e-n

        If no depth buffer is present, r is undefined.

        The bias value o for a polygon is

        o =m × depthBiasSlopeFactor + r × depthBiasConstantFactorwhen depthBiasClamp = 0 or NaN
        min(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, depthBiasClamp)when depthBiasClamp > 0
        max(m × depthBiasSlopeFactor + r × depthBiasConstantFactor, depthBiasClamp)when depthBiasClamp < 0

        m is computed as described above. If the depth buffer uses a fixed-point representation, m is a function of depth values in the range [0,1], and o is applied to depth values in the same range.

        For fixed-point depth buffers, fragment depth values are always limited to the range [0,1] by clamping after depth bias addition is performed. Fragment depth values are clamped even when the depth buffer uses a floating-point representation.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • If the depth bias clamping feature is not enabled, depthBiasClamp must be 0.0
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        depthBiasConstantFactor - a scalar factor controlling the constant depth value added to each fragment
        depthBiasClamp - the maximum (or minimum) depth bias of a fragment
        depthBiasSlopeFactor - a scalar factor applied to a fragment’s slope in depth bias calculations
      • vkCmdSetBlendConstants

        public static void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
                                                  java.nio.FloatBuffer blendConstants)

        Khronos Reference Page

        Sets the values of blend constants.

        If the pipeline state object is created without the DYNAMIC_STATE_BLEND_CONSTANTS dynamic state enabled then the “blend constant” (Rc,Gc,Bc,Ac) is specified via the blendConstants member of VkPipelineColorBlendStateCreateInfo. Otherwise the blend constant is dynamically set and changed by calling this command,

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        blendConstants - an array of four values specifying the R, G, B, and A components of the blend constant color used in blending, depending on the blend factor
      • vkCmdSetDepthBounds

        public static void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer,
                                               float minDepthBounds,
                                               float maxDepthBounds)

        Khronos Reference Page

        Sets the depth bounds test values for a command buffer.

        The depth bounds test conditionally disables coverage of a sample based on the outcome of a comparison between the value zaza in the depth attachment at location (xf,yf) (for the appropriate sample) and a range of values. The test is enabled or disabled by the depthBoundsTestEnable member of VkPipelineDepthStencilStateCreateInfo. If the pipeline state object is created without the DYNAMIC_STATE_DEPTH_BOUNDS dynamic state enabled then the range of values used in the depth bounds test are defined by the minDepthBounds and maxDepthBounds members of the VkPipelineDepthStencilStateCreateInfo structure. Otherwise, to dynamically set the depth bounds range values call this command.

        If minDepthBounds ≤ za ≤ maxDepthBounds, then the depth bounds test passes. Otherwise, the test fails and the sample’s coverage bit is cleared in the fragment. If there is no depth framebuffer attachment or if the depth bounds test is disabled, it is as if the depth bounds test always passes.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • minDepthBounds must be between 0.0 and 1.0, inclusive
        • maxDepthBounds must be between 0.0 and 1.0, inclusive
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        minDepthBounds - the lower bound of the range of depth values used in the depth bounds test
        maxDepthBounds - the upper bound of the range
      • vkCmdSetStencilCompareMask

        public static void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
                                                      int faceMask,
                                                      int compareMask)

        Khronos Reference Page

        Sets the stencil compare mask dynamic state.

        If the pipeline state object is created with the DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled, then to dynamically set the stencil compare mask call this command.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • faceMask must be a valid combination of VkStencilFaceFlagBits values
        • faceMask must not be 0
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        faceMask - a bitmask specifying the set of stencil state for which to update the compare mask. One or more of:
        STENCIL_FACE_FRONT_BITSTENCIL_FACE_BACK_BITSTENCIL_FRONT_AND_BACK
        compareMask - the new value to use as the stencil compare mask
      • vkCmdSetStencilWriteMask

        public static void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
                                                    int faceMask,
                                                    int writeMask)

        Khronos Reference Page

        Sets the stencil write mask dynamic state.

        If the pipeline state object is created with the DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled, then to dynamically set the stencil write mask call this command.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • faceMask must be a valid combination of VkStencilFaceFlagBits values
        • faceMask must not be 0
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        faceMask - a bitmask of VkStencilFaceFlagBits specifying the set of stencil state for which to update the write mask. One or more of:
        STENCIL_FACE_FRONT_BITSTENCIL_FACE_BACK_BITSTENCIL_FRONT_AND_BACK
        writeMask - the new value to use as the stencil write mask
      • vkCmdSetStencilReference

        public static void vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
                                                    int faceMask,
                                                    int reference)

        Khronos Reference Page

        Sets the stencil reference dynamic state.

        If the pipeline state object is created with the DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled, then to dynamically set the stencil reference value call this command.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • faceMask must be a valid combination of VkStencilFaceFlagBits values
        • faceMask must not be 0
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        faceMask - a bitmask of VkStencilFaceFlagBits specifying the set of stencil state for which to update the reference value. One or more of:
        STENCIL_FACE_FRONT_BITSTENCIL_FACE_BACK_BITSTENCIL_FRONT_AND_BACK
        reference - the new value to use as the stencil reference value
      • vkCmdBindDescriptorSets

        public static void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer,
                                                   int pipelineBindPoint,
                                                   long layout,
                                                   int firstSet,
                                                   java.nio.LongBuffer pDescriptorSets,
                                                   java.nio.IntBuffer pDynamicOffsets)

        Khronos Reference Page

        Binds descriptor sets to a command buffer.

        If any of the sets being bound include dynamic uniform or storage buffers, then pDynamicOffsets includes one element for each array element in each dynamic descriptor type binding in each set.

        vkCmdBindDescriptorSets causes the sets numbered [firstSet.. firstSet+descriptorSetCount-1] to use the bindings stored in pDescriptorSets[0..descriptorSetCount-1] for subsequent rendering commands (either compute or graphics, according to the pipelineBindPoint). Any bindings that were previously applied via these sets are no longer valid.

        Once bound, a descriptor set affects rendering of subsequent graphics or compute commands in the command buffer until a different set is bound to the same set number, or else until the set is disturbed.

        A compatible descriptor set must be bound for all set numbers that any shaders in a pipeline access, at the time that a draw or dispatch command is recorded to execute using that pipeline. However, if none of the shaders in a pipeline statically use any bindings with a particular set number, then no descriptor set need be bound for that set number, even if the pipeline layout includes a non-trivial descriptor set layout for that set number.

        If any of the sets being bound include dynamic uniform or storage buffers, then pDynamicOffsets includes one element for each array element in each dynamic descriptor type binding in each set. Values are taken from pDynamicOffsets in an order such that all entries for set N come before set N+1; within a set, entries are ordered by the binding numbers in the decriptor set layouts; and within a binding array, elements are in order. dynamicOffsetCount must equal the total number of dynamic descriptors in the sets being bound.

        The effective offset used for dynamic uniform and storage buffer bindings is the sum of the relative offset taken from pDynamicOffsets, and the base address of the buffer plus base offset in the descriptor set. The length of the dynamic uniform and storage buffer bindings is the buffer range as specified in the descriptor set.

        Each of the pDescriptorSets must be compatible with the pipeline layout specified by layout. The layout used to program the bindings must also be compatible with the pipeline used in subsequent graphics or compute commands.

        The descriptor set contents bound by a call to vkCmdBindDescriptorSets may be consumed during host execution of the command, or during shader execution of the resulting draws, or any time in between. Thus, the contents must not be altered (overwritten by an update command, or freed) between when the command is recorded and when the command completes executing on the queue. The contents of pDynamicOffsets are consumed immediately during execution of vkCmdBindDescriptorSets. Once all pending uses have completed, it is legal to update and reuse a descriptor set.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • pipelineBindPoint must be a valid VkPipelineBindPoint value
        • layout must be a valid VkPipelineLayout handle
        • pDescriptorSets must be a pointer to an array of descriptorSetCount valid VkDescriptorSet handles
        • If dynamicOffsetCount is not 0, pDynamicOffsets must be a pointer to an array of dynamicOffsetCount uint32_t values
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
        • descriptorSetCount must be greater than 0
        • Each of commandBuffer, layout and the elements of pDescriptorSets must have been created, allocated or retrieved from the same VkDevice
        • Any given element of pDescriptorSets must have been created with a VkDescriptorSetLayout that matches (is the same as, or defined identically to) the VkDescriptorSetLayout at set n in layout, where n is the sum of firstSet and the index into pDescriptorSets
        • dynamicOffsetCount must be equal to the total number of dynamic descriptors in pDescriptorSets
        • pipelineBindPoint must be supported by the commandBuffer's parent VkCommandPool's queue family
        • Any given element of pDynamicOffsets must satisfy the required alignment for the corresponding descriptor binding's descriptor type
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer that the descriptor sets will be bound to
        pipelineBindPoint - a VkPipelineBindPoint indicating whether the descriptors will be used by graphics pipelines or compute pipelines. There is a separate set of bind points for each of graphics and compute, so binding one does not disturb the other. One of:
        PIPELINE_BIND_POINT_GRAPHICSPIPELINE_BIND_POINT_COMPUTE
        layout - a VkPipelineLayout object used to program the bindings
        firstSet - the set number of the first descriptor set to be bound
        pDescriptorSets - a pointer to an array of VkDescriptorSet structures describing the descriptor sets to write to
        pDynamicOffsets - a pointer to an array of uint32_t values specifying dynamic offsets
      • vkCmdBindIndexBuffer

        public static void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer,
                                                long buffer,
                                                long offset,
                                                int indexType)

        Khronos Reference Page

        Binds an index buffer to a command buffer.
        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • buffer must be a valid VkBuffer handle
        • indexType must be a valid VkIndexType value
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • Each of commandBuffer and buffer must have been created, allocated or retrieved from the same VkDevice
        • offset must be less than the size of buffer
        • The sum of offset, and the address of the range of VkDeviceMemory object that's backing buffer, must be a multiple of the type indicated by indexType
        • buffer must have been created with the BUFFER_USAGE_INDEX_BUFFER_BIT flag
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command is recorded
        buffer - the buffer being bound
        offset - the starting offset in bytes within buffer used in index buffer address calculations
        indexType - selects whether indices are treated as 16 bits or 32 bits. One of:
        INDEX_TYPE_UINT16INDEX_TYPE_UINT32
      • vkCmdBindVertexBuffers

        public static void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer,
                                                  int firstBinding,
                                                  java.nio.LongBuffer pBuffers,
                                                  java.nio.LongBuffer pOffsets)

        Khronos Reference Page

        Binds vertex buffers to a command buffer.

        The values taken from elements i of pBuffers and pOffsets replace the current state for the vertex input binding firstBinding + i, for i in [0,bindingCount). The vertex input binding is updated to start at the offset indicated by pOffsets[i] from the start of the buffer pBuffers[i]. All vertex input attributes that use each of these bindings will use these updated addresses in their address calculations for subsequent draw commands.

        The address of each attribute for each vertexIndex and instanceIndex is calculated as follows:

        • Let attribDesc be the member of VkPipelineVertexInputStateCreateInfo::pVertexAttributeDescriptions with VkVertexInputAttributeDescription::location equal to the vertex input attribute number.
        • Let bindingDesc be the member of VkPipelineVertexInputStateCreateInfo::pVertexBindingDescriptions with VkVertexInputAttributeDescription::binding equal to attribDesc.binding.
        • Let vertexIndex be the index of the vertex within the draw (a value between firstVertex and firstVertex+vertexCount for CmdDraw, or a value taken from the index buffer for CmdDrawIndexed), and let instanceIndex be the instance number of the draw (a value between firstInstance and firstInstance+instanceCount).
        bufferBindingAddress = buffer[binding].baseAddress + offset[binding];
        
        if (bindingDesc.inputRate == VK_VERTEX_INPUT_RATE_VERTEX)
            vertexOffset = vertexIndex * bindingDesc.stride;
        else
            vertexOffset = instanceIndex * bindingDesc.stride;
        
        attribAddress = bufferBindingAddress + vertexOffset + attribDesc.offset;

        For each attribute, raw data is extracted starting at attribAddress and is converted from the VkVertexInputAttributeDescription’s format to either to floating-point, unsigned integer, or signed integer based on the base type of the format; the base type of the format must match the base type of the input variable in the shader. If format is a packed format, attribAddress must be a multiple of the size in bytes of the whole attribute data type. Otherwise, attribAddress must be a multiple of the size in bytes of the component type indicated by format. If the format does not include G, B, or A components, then those are filled with (0,0,1) as needed (using either 1.0f or integer 1 based on the format) for attributes that are not 64-bit data types. The number of components in the vertex shader input variable need not exactly match the number of components in the format. If the vertex shader has fewer components, the extra components are discarded.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • pBuffers must be a pointer to an array of bindingCount valid VkBuffer handles
        • pOffsets must be a pointer to an array of bindingCount VkDeviceSize values
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • bindingCount must be greater than 0
        • Each of commandBuffer and the elements of pBuffers must have been created, allocated or retrieved from the same VkDevice
        • firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings
        • The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings
        • All elements of pOffsets must be less than the size of the corresponding element in pBuffers
        • All elements of pBuffers must have been created with the BUFFER_USAGE_VERTEX_BUFFER_BIT flag
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command is recorded
        firstBinding - the index of the first vertex input binding whose state is updated by the command
        pBuffers - a pointer to an array of buffer handles
        pOffsets - a pointer to an array of buffer offsets
      • vkCmdDraw

        public static void vkCmdDraw(VkCommandBuffer commandBuffer,
                                     int vertexCount,
                                     int instanceCount,
                                     int firstVertex,
                                     int firstInstance)

        Khronos Reference Page

        Records a non-indexed draw.

        When the command is executed, primitives are assembled using the current primitive topology and vertexCount consecutive vertex indices with the first vertexIndex value equal to firstVertex. The primitives are drawn instanceCount times with instanceIndex starting with firstInstance and increasing sequentially for each instance. The assembled primitives execute the currently bound graphics pipeline.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called inside of a render pass instance
        • For each set n that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline
        • For each push constant that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline
        • Descriptors in each bound descriptor set, specified via CmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via CmdBindPipeline
        • All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound
        • For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding
        • A valid graphics pipeline must be bound to the current command buffer with PIPELINE_BIND_POINT_GRAPHICS
        • If the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
        • Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type IMAGE_VIEW_TYPE_3D, IMAGE_VIEW_TYPE_CUBE, IMAGE_VIEW_TYPE_1D_ARRAY, IMAGE_VIEW_TYPE_2D_ARRAY or IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or 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 any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • Any VkImageView being sampled with FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by GetPhysicalDeviceFormatProperties
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command is recorded
        vertexCount - the number of vertices to draw
        instanceCount - the number of instances to draw
        firstVertex - the index of the first vertex to draw
        firstInstance - the instance ID of the first instance to draw
      • vkCmdDrawIndexed

        public static void vkCmdDrawIndexed(VkCommandBuffer commandBuffer,
                                            int indexCount,
                                            int instanceCount,
                                            int firstIndex,
                                            int vertexOffset,
                                            int firstInstance)

        Khronos Reference Page

        Records an indexed draw call.

        When the command is executed, primitives are assembled using the current primitive topology and indexCount vertices whose indices are retrieved from the index buffer. The index buffer is treated as an array of tightly packed unsigned integers of size defined by the CmdBindIndexBuffer::indexType parameter with which the buffer was bound.

        The first vertex index is at an offset of firstIndex * indexSize + offset within the currently bound index buffer, where offset is the offset specified by vkCmdBindIndexBuffer and indexSize is the byte size of the type specified by indexType. Subsequent index values are retrieved from consecutive locations in the index buffer. Indices are first compared to the primitive restart value, then zero extended to 32 bits (if the indexType is INDEX_TYPE_UINT16) and have vertexOffset added to them, before being supplied as the vertexIndex value.

        The primitives are drawn instanceCount times with instanceIndex starting with firstInstance and increasing sequentially for each instance. The assembled primitives execute the currently bound graphics pipeline.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called inside of a render pass instance
        • For each set n that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline
        • For each push constant that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline
        • Descriptors in each bound descriptor set, specified via CmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via CmdBindPipeline
        • All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound
        • For a given vertex buffer binding, any attribute data fetched must be entirely contained within the corresponding vertex buffer binding
        • A valid graphics pipeline must be bound to the current command buffer with PIPELINE_BIND_POINT_GRAPHICS
        • If the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
        • (indexSize * (firstIndex + indexCount) + offset) must be less than or equal to the size of the currently bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via CmdBindIndexBuffer
        • Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type IMAGE_VIEW_TYPE_3D, IMAGE_VIEW_TYPE_CUBE, IMAGE_VIEW_TYPE_1D_ARRAY, IMAGE_VIEW_TYPE_2D_ARRAY or IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or 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 any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • Any VkImageView being sampled with FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by GetPhysicalDeviceFormatProperties
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command is recorded
        indexCount - the number of vertices to draw
        instanceCount - the number of instances to draw
        firstIndex - the base index within the index buffer
        vertexOffset - the value added to the vertex index before indexing into the vertex buffer
        firstInstance - the instance ID of the first instance to draw
      • vkCmdDrawIndirect

        public static void vkCmdDrawIndirect(VkCommandBuffer commandBuffer,
                                             long buffer,
                                             long offset,
                                             int drawCount,
                                             int stride)

        Khronos Reference Page

        Records a non-indexed indirect draw.

        vkCmdDrawIndirect behaves similarly to CmdDraw except that the parameters are read by the device from a buffer during execution. drawCount draws are executed by the command, with parameters taken from buffer starting at offset and increasing by stride bytes for each successive draw. The parameters of each draw are encoded in an array of VkDrawIndirectCommand structures. If drawCount is less than or equal to one, stride is ignored.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • buffer must be a valid VkBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called inside of a render pass instance
        • Each of commandBuffer and buffer must have been created, allocated or retrieved from the same VkDevice
        • offset must be a multiple of 4
        • If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndirectCommand)
        • If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1
        • If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndirectCommand structures accessed by this command must be 0
        • For each set n that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline
        • For each push constant that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline
        • Descriptors in each bound descriptor set, specified via CmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via CmdBindPipeline
        • All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound
        • A valid graphics pipeline must be bound to the current command buffer with PIPELINE_BIND_POINT_GRAPHICS
        • If the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
        • If drawCount is equal to 1, (offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
        • If drawCount is greater than 1, (stride x (drawCount - 1) + offset + sizeof(VkDrawIndirectCommand)) must be less than or equal to the size of buffer
        • drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount
        • Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type IMAGE_VIEW_TYPE_3D, IMAGE_VIEW_TYPE_CUBE, IMAGE_VIEW_TYPE_1D_ARRAY, IMAGE_VIEW_TYPE_2D_ARRAY or IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or 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 any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • Any VkImageView being sampled with FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by GetPhysicalDeviceFormatProperties
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command is recorded
        buffer - the buffer containing draw parameters
        offset - the byte offset into buffer where parameters begin
        drawCount - the number of draws to execute, and can be zero
        stride - the byte stride between successive sets of draw parameters
      • vkCmdDrawIndexedIndirect

        public static void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer,
                                                    long buffer,
                                                    long offset,
                                                    int drawCount,
                                                    int stride)

        Khronos Reference Page

        Records an indexed indirect draw.

        vkCmdDrawIndexedIndirect behaves similarly to CmdDrawIndirect except that the parameters are read by the device from a buffer during execution. drawCount draws are executed by the command, with parameters taken from buffer starting at offset and increasing by stride bytes for each successive draw. The parameters of each draw are encoded in an array of VkDrawIndexedIndirectCommand structures. If drawCount is less than or equal to one, stride is ignored.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • buffer must be a valid VkBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called inside of a render pass instance
        • Each of commandBuffer and buffer must have been created, allocated or retrieved from the same VkDevice
        • offset must be a multiple of 4
        • If drawCount is greater than 1, stride must be a multiple of 4 and must be greater than or equal to sizeof(VkDrawIndexedIndirectCommand)
        • If the multi-draw indirect feature is not enabled, drawCount must be 0 or 1
        • If the drawIndirectFirstInstance feature is not enabled, all the firstInstance members of the VkDrawIndexedIndirectCommand structures accessed by this command must be 0
        • For each set n that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must have been bound to n at PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline
        • For each push constant that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS, a push constant value must have been set for PIPELINE_BIND_POINT_GRAPHICS, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline
        • Descriptors in each bound descriptor set, specified via CmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via CmdBindPipeline
        • All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have valid buffers bound
        • A valid graphics pipeline must be bound to the current command buffer with PIPELINE_BIND_POINT_GRAPHICS
        • If the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must have been set on the current command buffer
        • If drawCount is equal to 1, (offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
        • If drawCount is greater than 1, (stride x (drawCount - 1) + offset + sizeof(VkDrawIndexedIndirectCommand)) must be less than or equal to the size of buffer
        • drawCount must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount
        • Every input attachment used by the current subpass must be bound to the pipeline via a descriptor set
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type IMAGE_VIEW_TYPE_3D, IMAGE_VIEW_TYPE_CUBE, IMAGE_VIEW_TYPE_1D_ARRAY, IMAGE_VIEW_TYPE_2D_ARRAY or IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or 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 any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • Any VkImageView being sampled with FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by GetPhysicalDeviceFormatProperties
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command is recorded
        buffer - the buffer containing draw parameters
        offset - the byte offset into buffer where parameters begin
        drawCount - the number of draws to execute, and can be zero
        stride - the byte stride between successive sets of draw parameters
      • vkCmdDispatch

        public static void vkCmdDispatch(VkCommandBuffer commandBuffer,
                                         int x,
                                         int y,
                                         int z)

        Khronos Reference Page

        Records a dispatch.

        Dispatching commands (commands with “Dispatch” in the name) provoke work in a compute pipeline. Dispatching commands are recorded into a command buffer and when executed by a queue, will produce work which executes according to the currently bound compute pipeline. A compute pipeline must be bound to a command buffer before any dispatch commands are recorded in that command buffer.

        When the command is executed, a global workgroup consisting of x × y × z local workgroups is assembled.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support compute operations
        • This command must only be called outside of a render pass instance
        • x must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0]
        • y must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[1]
        • z must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[2]
        • For each set n that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline
        • Descriptors in each bound descriptor set, specified via CmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via CmdBindPipeline
        • A valid compute pipeline must be bound to the current command buffer with PIPELINE_BIND_POINT_COMPUTE
        • For each push constant that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type IMAGE_VIEW_TYPE_3D, IMAGE_VIEW_TYPE_CUBE, IMAGE_VIEW_TYPE_1D_ARRAY, IMAGE_VIEW_TYPE_2D_ARRAY or IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or 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 any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • Any VkImageView being sampled with FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by GetPhysicalDeviceFormatProperties
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        x - the number of local workgroups to dispatch in the X dimension
        y - the number of local workgroups to dispatch in the Y dimension
        z - the number of local workgroups to dispatch in the Z dimension
      • vkCmdDispatchIndirect

        public static void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer,
                                                 long buffer,
                                                 long offset)

        Khronos Reference Page

        Records an indirect dispatch.
        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • buffer must be a valid VkBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support compute operations
        • This command must only be called outside of a render pass instance
        • Each of commandBuffer and buffer must have been created, allocated or retrieved from the same VkDevice
        • For each set n that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_COMPUTE, a descriptor set must have been bound to n at PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline
        • Descriptors in each bound descriptor set, specified via CmdBindDescriptorSets, must be valid if they are statically used by the currently bound VkPipeline object, specified via CmdBindPipeline
        • A valid compute pipeline must be bound to the current command buffer with PIPELINE_BIND_POINT_COMPUTE
        • buffer must have been created with the BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set
        • offset must be a multiple of 4
        • The sum of offset and the size of VkDispatchIndirectCommand must be less than or equal to the size of buffer
        • For each push constant that is statically used by the VkPipeline currently bound to PIPELINE_BIND_POINT_COMPUTE, a push constant value must have been set for PIPELINE_BIND_POINT_COMPUTE, with a VkPipelineLayout that is compatible for push constants with the one used to create the current VkPipeline
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used to sample from any VkImage with a VkImageView of the type IMAGE_VIEW_TYPE_3D, IMAGE_VIEW_TYPE_CUBE, IMAGE_VIEW_TYPE_1D_ARRAY, IMAGE_VIEW_TYPE_2D_ARRAY or IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
        • If any VkSampler object that is accessed from a shader by the VkPipeline currently bound to PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it must not be used with any of the SPIR-V OpImageSample* or 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 any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • If the robust buffer access feature is not enabled, and any shader stage in the VkPipeline object currently bound to PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it must not access values outside of the range of that buffer specified in the currently bound descriptor set
        • Any VkImageView being sampled with FILTER_LINEAR as a result of this command must be of a format which supports linear filtering, as specified by the FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by GetPhysicalDeviceFormatProperties
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        buffer - the buffer containing dispatch parameters
        offset - the byte offset into buffer where parameters begin
      • vkCmdCopyBuffer

        public static void vkCmdCopyBuffer(VkCommandBuffer commandBuffer,
                                           long srcBuffer,
                                           long dstBuffer,
                                           VkBufferCopy.Buffer pRegions)

        Khronos Reference Page

        Copies data between buffer objects.

        Each region in pRegions is copied from the source buffer to the same region of the destination buffer. srcBuffer and dstBuffer can be the same buffer or alias the same memory, but the result is undefined if the copy regions overlap in memory.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • srcBuffer must be a valid VkBuffer handle
        • dstBuffer must be a valid VkBuffer handle
        • pRegions must be a pointer to an array of regionCount VkBufferCopy structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations
        • This command must only be called outside of a render pass instance
        • regionCount must be greater than 0
        • Each of commandBuffer, srcBuffer and dstBuffer must have been created, allocated or retrieved from the same VkDevice
        • The size member of a given element of pRegions must be greater than 0
        • The srcOffset member of a given element of pRegions must be less than the size of srcBuffer
        • The dstOffset member of a given element of pRegions must be less than the size of dstBuffer
        • The size member of a given element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset
        • The size member of a given element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset
        • The union of the source regions, and the union of the destination regions, specified by the elements of pRegions, must not overlap in memory
        • srcBuffer must have been created with BUFFER_USAGE_TRANSFER_SRC_BIT usage flag
        • dstBuffer must have been created with BUFFER_USAGE_TRANSFER_DST_BIT usage flag
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        srcBuffer - the source buffer
        dstBuffer - the destination buffer
        pRegions - a pointer to an array of VkBufferCopy structures specifying the regions to copy
      • vkCmdCopyImage

        public static void vkCmdCopyImage(VkCommandBuffer commandBuffer,
                                          long srcImage,
                                          int srcImageLayout,
                                          long dstImage,
                                          int dstImageLayout,
                                          VkImageCopy.Buffer pRegions)

        Khronos Reference Page

        Copy data between image objects.

        vkCmdCopyImage performs image copies in a similar manner to a host memcpy. It does not perform general-purpose conversions such as scaling, resizing, blending, color-space conversion, or format conversions. Rather, it simply copies raw image data. vkCmdCopyImage can copy between images with different formats, provided the formats are compatible.

        Each region in pRegions is copied from the source image to the same region of the destination image. srcImage and dstImage can be the same image or alias the same memory.

        Copies are done layer by layer starting with baseArrayLayer member of srcSubresource for the source and dstSubresource for the destination. layerCount layers are copied to the destination image.

        The formats of srcImage and dstImage must be compatible. Formats are considered compatible if their texel size in bytes is the same between both formats. For example, FORMAT_R8G8B8A8_UNORM is compatible with FORMAT_R32_UINT because because both texels are 4 bytes in size. Depth/stencil formats must match exactly.

        vkCmdCopyImage allows copying between size-compatible compressed and uncompressed internal formats. Formats are size-compatible if the texel size of the uncompressed format is equal to the block size in bytes of the compressed format. Such a copy does not perform on-the-fly compression or decompression. When copying from an uncompressed format to a compressed format, each texel of uncompressed data becomes a single block of compressed data. When copying from a compressed format to an uncompressed format, a block of compressed data becomes a single texel of uncompressed data. Thus, for example, it is legal to copy between a 128-bit uncompressed format and a compressed format which uses 8-bit/texel 4x4 blocks, or between a 64-bit uncompressed format and a compressed format which uses 4-bit/texel 4x4 blocks.

        When copying between compressed and uncompressed formats the extent members represent the texel dimensions of the source image and not the destination. When copying from a compressed image to an uncompressed image the image texel dimensions written to the uncompressed image will be source extent divided by the block size. When copying from an uncompressed image to a compressed image the image texel dimensions written to the compressed image will be the source extent multiplied by the block size. In both cases the number of bytes read and the number of bytes written will be identical.

        Copying to or from block-compressed images is typically done in multiples of the block. For this reason the extent must be a multiple of the block dimension. There is one exception to this rule which is required to handle compressed images created with dimensions that are not a multiple of the block dimensions. If the srcImage is compressed and if extent.width is not a multiple of the block width then (extent.width + srcOffset.x) must equal the image subresource width, if extent.height is not a multiple of the block height then (extent.height + srcOffset.y) must equal the image subresource height and if extent.depth is not a multiple of the block depth then (extent.depth + srcOffset.z) must equal the image subresource depth. Similarly if the dstImage is compressed and if extent.width is not a multiple of the block width then (extent.width + dstOffset.x) must equal the image subresource width, if extent.height is not a multiple of the block height then (extent.height + dstOffset.y) must equal the image subresource height and if extent.depth is not a multiple of the block depth then (extent.depth + dstOffset.z) must equal the image subresource depth. This allows the last block of the image in each non-multiple dimension to be included as a source or target of the copy.

        vkCmdCopyImage can be used to copy image data between multisample images, but both images must have the same number of samples.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • srcImage must be a valid VkImage handle
        • srcImageLayout must be a valid VkImageLayout value
        • dstImage must be a valid VkImage handle
        • dstImageLayout must be a valid VkImageLayout value
        • pRegions must be a pointer to an array of regionCount valid VkImageCopy structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations
        • This command must only be called outside of a render pass instance
        • regionCount must be greater than 0
        • Each of commandBuffer, srcImage and dstImage must have been created, allocated or retrieved from the same VkDevice
        • The source region specified by a given element of pRegions must be a region that is contained within srcImage
        • The destination region specified by a given element of pRegions must be a region that is contained within dstImage
        • The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
        • srcImage must have been created with IMAGE_USAGE_TRANSFER_SRC_BIT usage flag
        • srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
        • srcImageLayout must be either of IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • dstImage must have been created with IMAGE_USAGE_TRANSFER_DST_BIT usage flag
        • dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
        • dstImageLayout must be either of IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • The VkFormat of each of srcImage and dstImage must be compatible, as defined below
        • The sample count of srcImage and dstImage must match
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        srcImage - the source image
        srcImageLayout - the current layout of the source image subresource
        dstImage - the destination image
        dstImageLayout - the current layout of the destination image subresource
        pRegions - a pointer to an array of VkImageCopy structures specifying the regions to copy
      • vkCmdBlitImage

        public static void vkCmdBlitImage(VkCommandBuffer commandBuffer,
                                          long srcImage,
                                          int srcImageLayout,
                                          long dstImage,
                                          int dstImageLayout,
                                          VkImageBlit.Buffer pRegions,
                                          int filter)

        Khronos Reference Page

        Copies regions of a source image into a destination image, potentially performing format conversion, arbitrary scaling, and filtering.

        vkCmdBlitImage must not be used for multisampled source or destination images. Use CmdResolveImage for this purpose.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • srcImage must be a valid VkImage handle
        • srcImageLayout must be a valid VkImageLayout value
        • dstImage must be a valid VkImage handle
        • dstImageLayout must be a valid VkImageLayout value
        • pRegions must be a pointer to an array of regionCount valid VkImageBlit structures
        • filter must be a valid VkFilter value
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called outside of a render pass instance
        • regionCount must be greater than 0
        • Each of commandBuffer, srcImage and dstImage must have been created, allocated or retrieved from the same VkDevice
        • The source region specified by a given element of pRegions must be a region that is contained within srcImage
        • The destination region specified by a given element of pRegions must be a region that is contained within dstImage
        • The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
        • srcImage must use a format that supports FORMAT_FEATURE_BLIT_SRC_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linear tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by GetPhysicalDeviceFormatProperties
        • srcImage must have been created with IMAGE_USAGE_TRANSFER_SRC_BIT usage flag
        • srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
        • srcImageLayout must be either of IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • dstImage must use a format that supports FORMAT_FEATURE_BLIT_DST_BIT, which is indicated by VkFormatProperties::linearTilingFeatures (for linear tiled images) or VkFormatProperties::optimalTilingFeatures (for optimally tiled images) - as returned by GetPhysicalDeviceFormatProperties
        • dstImage must have been created with IMAGE_USAGE_TRANSFER_DST_BIT usage flag
        • dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
        • dstImageLayout must be either of IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • The sample count of srcImage and dstImage must both be equal to SAMPLE_COUNT_1_BIT
        • If either of srcImage or dstImage was created with a signed integer VkFormat, the other must also have been created with a signed integer VkFormat
        • If either of srcImage or dstImage was created with an unsigned integer VkFormat, the other must also have been created with an unsigned integer VkFormat
        • If either of srcImage or dstImage was created with a depth/stencil format, the other must have exactly the same format
        • If srcImage was created with a depth/stencil format, filter must be FILTER_NEAREST
        • If filter is FILTER_LINEAR, srcImage must be of a format which supports linear filtering, as specified by the FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in VkFormatProperties::linearTilingFeatures (for a linear image) or VkFormatProperties::optimalTilingFeatures(for an optimally tiled image) returned by GetPhysicalDeviceFormatProperties
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        srcImage - the source image
        srcImageLayout - the layout of the source image subresources for the blit
        dstImage - the destination image
        dstImageLayout - the layout of the destination image subresources for the blit
        pRegions - a pointer to an array of VkImageBlit structures specifying the regions to blit
        filter - a VkFilter specifying the filter to apply if the blits require scaling
      • vkCmdCopyBufferToImage

        public static void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,
                                                  long srcBuffer,
                                                  long dstImage,
                                                  int dstImageLayout,
                                                  VkBufferImageCopy.Buffer pRegions)

        Khronos Reference Page

        Copies data from a buffer object to an image object.

        Each region in pRegions is copied from the specified region of the source buffer to the specified region of the destination image.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • srcBuffer must be a valid VkBuffer handle
        • dstImage must be a valid VkImage handle
        • dstImageLayout must be a valid VkImageLayout value
        • pRegions must be a pointer to an array of regionCount valid VkBufferImageCopy structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations
        • This command must only be called outside of a render pass instance
        • regionCount must be greater than 0
        • Each of commandBuffer, srcBuffer and dstImage must have been created, allocated or retrieved from the same VkDevice
        • The buffer region specified by a given element of pRegions must be a region that is contained within srcBuffer
        • The image region specified by a given element of pRegions must be a region that is contained within dstImage
        • The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
        • srcBuffer must have been created with BUFFER_USAGE_TRANSFER_SRC_BIT usage flag
        • dstImage must have been created with IMAGE_USAGE_TRANSFER_DST_BIT usage flag
        • dstImage must have a sample count equal to SAMPLE_COUNT_1_BIT
        • dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
        • dstImageLayout must be either of IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or IMAGE_LAYOUT_GENERAL
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        srcBuffer - the source buffer
        dstImage - the destination image
        dstImageLayout - the layout of the destination image subresources for the copy
        pRegions - a pointer to an array of VkBufferImageCopy structures specifying the regions to copy
      • vkCmdCopyImageToBuffer

        public static void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
                                                  long srcImage,
                                                  int srcImageLayout,
                                                  long dstBuffer,
                                                  VkBufferImageCopy.Buffer pRegions)

        Khronos Reference Page

        Copies data from an image object to a buffer object.

        Each region in pRegions is copied from the specified region of the source image to the specified region of the destination buffer.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • srcImage must be a valid VkImage handle
        • srcImageLayout must be a valid VkImageLayout value
        • dstBuffer must be a valid VkBuffer handle
        • pRegions must be a pointer to an array of regionCount valid VkBufferImageCopy structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations
        • This command must only be called outside of a render pass instance
        • regionCount must be greater than 0
        • Each of commandBuffer, srcImage and dstBuffer must have been created, allocated or retrieved from the same VkDevice
        • The image region specified by a given element of pRegions must be a region that is contained within srcImage
        • The buffer region specified by a given element of pRegions must be a region that is contained within dstBuffer
        • The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
        • srcImage must have been created with IMAGE_USAGE_TRANSFER_SRC_BIT usage flag
        • srcImage must have a sample count equal to SAMPLE_COUNT_1_BIT
        • srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
        • srcImageLayout must be either of IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • dstBuffer must have been created with BUFFER_USAGE_TRANSFER_DST_BIT usage flag
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        srcImage - the source image
        srcImageLayout - the layout of the source image subresources for the copy
        dstBuffer - the destination buffer
        pRegions - a pointer to an array of VkBufferImageCopy structures specifying the regions to copy
      • vkCmdUpdateBuffer

        public static void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer,
                                             long dstBuffer,
                                             long dstOffset,
                                             java.nio.IntBuffer pData)

        Khronos Reference Page

        Updates buffer data inline in a command buffer.

        The source data is copied from the user pointer to the command buffer when the command is called.

        vkCmdUpdateBuffer is only allowed outside of a render pass. This command is treated as “transfer” operation, for the purposes of synchronization barriers. The BUFFER_USAGE_TRANSFER_DST_BIT must be specified in usage of VkBufferCreateInfo in order for the buffer to be compatible with vkCmdUpdateBuffer.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • dstBuffer must be a valid VkBuffer handle
        • pData must be a pointer to an array of dataSize / 4 uint32_t values
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations
        • This command must only be called outside of a render pass instance
        • Each of commandBuffer and dstBuffer must have been created, allocated or retrieved from the same VkDevice
        • dataSize must be greater than 0
        • dstOffset must be less than the size of dstBuffer
        • dataSize must be less than or equal to the size of dstBuffer minus dstOffset
        • dstBuffer must have been created with BUFFER_USAGE_TRANSFER_DST_BIT usage flag
        • dstOffset must be a multiple of 4
        • dataSize must be less than or equal to 65536
        • dataSize must be a multiple of 4
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        dstBuffer - a handle to the buffer to be updated
        dstOffset - the byte offset into the buffer to start updating, and must be a multiple of 4
        pData - a pointer to the source data for the buffer update, and must be at least dataSize bytes in size
      • vkCmdFillBuffer

        public static void vkCmdFillBuffer(VkCommandBuffer commandBuffer,
                                           long dstBuffer,
                                           long dstOffset,
                                           long size,
                                           int data)

        Khronos Reference Page

        Fills a region of a buffer with a fixed value.

        vkCmdFillBuffer is treated as “transfer” operation for the purposes of synchronization barriers. The BUFFER_USAGE_TRANSFER_DST_BIT must be specified in usage of VkBufferCreateInfo in order for the buffer to be compatible with vkCmdFillBuffer.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • dstBuffer must be a valid VkBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
        • This command must only be called outside of a render pass instance
        • Each of commandBuffer and dstBuffer must have been created, allocated or retrieved from the same VkDevice
        • dstOffset must be less than the size of dstBuffer
        • dstOffset must be a multiple of 4
        • If size is not equal to WHOLE_SIZE, size must be greater than 0
        • If size is not equal to WHOLE_SIZE, size must be less than or equal to the size of dstBuffer minus dstOffset
        • If size is not equal to WHOLE_SIZE, size must be a multiple of 4
        • dstBuffer must have been created with BUFFER_USAGE_TRANSFER_DST_BIT usage flag
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        dstBuffer - the buffer to be filled
        dstOffset - the byte offset into the buffer at which to start filling, and must be a multiple of 4
        size - the number of bytes to fill, and must be either a multiple of 4, or WHOLE_SIZE to fill the range from offset to the end of the buffer. If WHOLE_SIZE is used and the remaining size of the buffer is not a multiple of 4, then the nearest smaller multiple is used.
        data - the 4-byte word written repeatedly to the buffer to fill size bytes of data. The data word is written to memory according to the host endianness.
      • vkCmdClearColorImage

        public static void vkCmdClearColorImage(VkCommandBuffer commandBuffer,
                                                long image,
                                                int imageLayout,
                                                VkClearColorValue pColor,
                                                VkImageSubresourceRange.Buffer pRanges)

        Khronos Reference Page

        Clears one or more subranges of a color image.

        Each specified range in pRanges is cleared to the value specified by pColor.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • image must be a valid VkImage handle
        • imageLayout must be a valid VkImageLayout value
        • pColor must be a pointer to a valid VkClearColorValue union
        • pRanges must be a pointer to an array of rangeCount valid VkImageSubresourceRange structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
        • This command must only be called outside of a render pass instance
        • rangeCount must be greater than 0
        • Each of commandBuffer and image must have been created, allocated or retrieved from the same VkDevice
        • image must have been created with IMAGE_USAGE_TRANSFER_DST_BIT usage flag
        • imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice
        • imageLayout must be either of IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • The image range of any given element of pRanges must be an image subresource range that is contained within image
        • image must not have a compressed or depth/stencil format
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        image - the image to be cleared
        imageLayout - the current layout of the image subresource ranges to be cleared. One of:
        IMAGE_LAYOUT_GENERALIMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
        pColor - a pointer to a VkClearColorValue structure that contains the values the image subresource ranges will be cleared to
        pRanges - points to an array of VkImageSubresourceRange structures that describe a range of mipmap levels, array layers, and aspects to be cleared. The aspectMask of all image subresource ranges must only include IMAGE_ASPECT_COLOR_BIT.
      • vkCmdClearColorImage

        public static void vkCmdClearColorImage(VkCommandBuffer commandBuffer,
                                                long image,
                                                int imageLayout,
                                                VkClearColorValue pColor,
                                                VkImageSubresourceRange pRange)

        Khronos Reference Page

        Clears one or more subranges of a color image.

        Each specified range in pRanges is cleared to the value specified by pColor.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • image must be a valid VkImage handle
        • imageLayout must be a valid VkImageLayout value
        • pColor must be a pointer to a valid VkClearColorValue union
        • pRanges must be a pointer to an array of rangeCount valid VkImageSubresourceRange structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
        • This command must only be called outside of a render pass instance
        • rangeCount must be greater than 0
        • Each of commandBuffer and image must have been created, allocated or retrieved from the same VkDevice
        • image must have been created with IMAGE_USAGE_TRANSFER_DST_BIT usage flag
        • imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice
        • imageLayout must be either of IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • The image range of any given element of pRanges must be an image subresource range that is contained within image
        • image must not have a compressed or depth/stencil format
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        image - the image to be cleared
        imageLayout - the current layout of the image subresource ranges to be cleared. One of:
        IMAGE_LAYOUT_GENERALIMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
        pColor - a pointer to a VkClearColorValue structure that contains the values the image subresource ranges will be cleared to
      • vkCmdClearDepthStencilImage

        public static void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer,
                                                       long image,
                                                       int imageLayout,
                                                       VkClearDepthStencilValue pDepthStencil,
                                                       VkImageSubresourceRange.Buffer pRanges)

        Khronos Reference Page

        Clears one or more subranges of a depth/stencil image.
        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • image must be a valid VkImage handle
        • imageLayout must be a valid VkImageLayout value
        • pDepthStencil must be a pointer to a valid VkClearDepthStencilValue structure
        • pRanges must be a pointer to an array of rangeCount valid VkImageSubresourceRange structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called outside of a render pass instance
        • rangeCount must be greater than 0
        • Each of commandBuffer and image must have been created, allocated or retrieved from the same VkDevice
        • image must have been created with IMAGE_USAGE_TRANSFER_DST_BIT usage flag
        • imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice
        • imageLayout must be either of IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • The image range of any given element of pRanges must be an image subresource range that is contained within image
        • image must have a depth/stencil format
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        image - the image to be cleared
        imageLayout - the current layout of the image subresource ranges to be cleared. One of:
        IMAGE_LAYOUT_GENERALIMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
        pDepthStencil - a pointer to a VkClearDepthStencilValue structure that contains the values the depth and stencil image subresource ranges will be cleared to
        pRanges - points to an array of VkImageSubresourceRange structures that describe a range of mipmap levels, array layers, and aspects to be cleared. The aspectMask of each image subresource range in pRanges can include IMAGE_ASPECT_DEPTH_BIT if the image format has a depth component, and IMAGE_ASPECT_STENCIL_BIT if the image format has a stencil component. pDepthStencil is a pointer to a VkClearDepthStencilValue structure that contains the values the image subresource ranges will be cleared to.
      • vkCmdClearDepthStencilImage

        public static void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer,
                                                       long image,
                                                       int imageLayout,
                                                       VkClearDepthStencilValue pDepthStencil,
                                                       VkImageSubresourceRange pRange)

        Khronos Reference Page

        Clears one or more subranges of a depth/stencil image.
        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • image must be a valid VkImage handle
        • imageLayout must be a valid VkImageLayout value
        • pDepthStencil must be a pointer to a valid VkClearDepthStencilValue structure
        • pRanges must be a pointer to an array of rangeCount valid VkImageSubresourceRange structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called outside of a render pass instance
        • rangeCount must be greater than 0
        • Each of commandBuffer and image must have been created, allocated or retrieved from the same VkDevice
        • image must have been created with IMAGE_USAGE_TRANSFER_DST_BIT usage flag
        • imageLayout must specify the layout of the image subresource ranges of image specified in pRanges at the time this command is executed on a VkDevice
        • imageLayout must be either of IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • The image range of any given element of pRanges must be an image subresource range that is contained within image
        • image must have a depth/stencil format
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        image - the image to be cleared
        imageLayout - the current layout of the image subresource ranges to be cleared. One of:
        IMAGE_LAYOUT_GENERALIMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
        pDepthStencil - a pointer to a VkClearDepthStencilValue structure that contains the values the depth and stencil image subresource ranges will be cleared to
      • vkCmdClearAttachments

        public static void vkCmdClearAttachments(VkCommandBuffer commandBuffer,
                                                 VkClearAttachment.Buffer pAttachments,
                                                 VkClearRect.Buffer pRects)

        Khronos Reference Page

        Clears one or more regions of color and depth/stencil attachments inside a render pass instance.

        vkCmdClearAttachments can clear multiple regions of each attachment used in the current subpass of a render pass instance. This command must be called only inside a render pass instance, and implicitly selects the images to clear based on the current framebuffer attachments and the command parameters.

        No memory barriers are needed between vkCmdClearAttachments and preceding or subsequent draw or attachment clear commands in the same subpass.

        The vkCmdClearAttachments command is not affected by the bound pipeline state.

        Attachments can also be cleared at the beginning of a render pass instance by setting loadOp (or stencilLoadOp) of VkAttachmentDescription to ATTACHMENT_LOAD_OP_CLEAR, as described for CreateRenderPass.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • pAttachments must be a pointer to an array of attachmentCount valid VkClearAttachment structures
        • pRects must be a pointer to an array of rectCount VkClearRect structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called inside of a render pass instance
        • attachmentCount must be greater than 0
        • rectCount must be greater than 0
        • If the aspectMask member of any given element of pAttachments contains IMAGE_ASPECT_COLOR_BIT, the colorAttachment member of those elements must refer to a valid color attachment in the current subpass
        • The rectangular region specified by a given element of pRects must be contained within the render area of the current render pass instance
        • The layers specified by a given element of pRects must be contained within every attachment that pAttachments refers to
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        pAttachments - a pointer to an array of VkClearAttachment structures defining the attachments to clear and the clear values to use
        pRects - points to an array of VkClearRect structures defining regions within each selected attachment to clear
      • vkCmdResolveImage

        public static void vkCmdResolveImage(VkCommandBuffer commandBuffer,
                                             long srcImage,
                                             int srcImageLayout,
                                             long dstImage,
                                             int dstImageLayout,
                                             VkImageResolve.Buffer pRegions)

        Khronos Reference Page

        Resolves a multisample image to a non-multisample image.
        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • srcImage must be a valid VkImage handle
        • srcImageLayout must be a valid VkImageLayout value
        • dstImage must be a valid VkImage handle
        • dstImageLayout must be a valid VkImageLayout value
        • pRegions must be a pointer to an array of regionCount valid VkImageResolve structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called outside of a render pass instance
        • regionCount must be greater than 0
        • Each of commandBuffer, srcImage and dstImage must have been created, allocated or retrieved from the same VkDevice
        • The source region specified by a given element of pRegions must be a region that is contained within srcImage
        • The destination region specified by a given element of pRegions must be a region that is contained within dstImage
        • The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
        • srcImage must have a sample count equal to any valid sample count value other than SAMPLE_COUNT_1_BIT
        • dstImage must have a sample count equal to SAMPLE_COUNT_1_BIT
        • srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
        • srcImageLayout must be either of IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
        • dstImageLayout must be either of IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • If dstImage was created with tiling equal to IMAGE_TILING_LINEAR, dstImage must have been created with a format that supports being a color attachment, as specified by the FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by GetPhysicalDeviceFormatProperties
        • If dstImage was created with tiling equal to IMAGE_TILING_OPTIMAL, dstImage must have been created with a format that supports being a color attachment, as specified by the FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by GetPhysicalDeviceFormatProperties
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        srcImage - the source image
        srcImageLayout - the layout of the source image subresources for the resolve
        dstImage - the destination image
        dstImageLayout - the layout of the destination image subresources for the resolve
        pRegions - a pointer to an array of VkImageResolve structures specifying the regions to resolve
      • vkCmdResolveImage

        public static void vkCmdResolveImage(VkCommandBuffer commandBuffer,
                                             long srcImage,
                                             int srcImageLayout,
                                             long dstImage,
                                             int dstImageLayout,
                                             VkImageResolve pRegion)

        Khronos Reference Page

        Resolves a multisample image to a non-multisample image.
        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • srcImage must be a valid VkImage handle
        • srcImageLayout must be a valid VkImageLayout value
        • dstImage must be a valid VkImage handle
        • dstImageLayout must be a valid VkImageLayout value
        • pRegions must be a pointer to an array of regionCount valid VkImageResolve structures
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called outside of a render pass instance
        • regionCount must be greater than 0
        • Each of commandBuffer, srcImage and dstImage must have been created, allocated or retrieved from the same VkDevice
        • The source region specified by a given element of pRegions must be a region that is contained within srcImage
        • The destination region specified by a given element of pRegions must be a region that is contained within dstImage
        • The union of all source regions, and the union of all destination regions, specified by the elements of pRegions, must not overlap in memory
        • srcImage must have a sample count equal to any valid sample count value other than SAMPLE_COUNT_1_BIT
        • dstImage must have a sample count equal to SAMPLE_COUNT_1_BIT
        • srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice
        • srcImageLayout must be either of IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice
        • dstImageLayout must be either of IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or IMAGE_LAYOUT_GENERAL
        • If dstImage was created with tiling equal to IMAGE_TILING_LINEAR, dstImage must have been created with a format that supports being a color attachment, as specified by the FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::linearTilingFeatures returned by GetPhysicalDeviceFormatProperties
        • If dstImage was created with tiling equal to IMAGE_TILING_OPTIMAL, dstImage must have been created with a format that supports being a color attachment, as specified by the FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in VkFormatProperties::optimalTilingFeatures returned by GetPhysicalDeviceFormatProperties
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded
        srcImage - the source image
        srcImageLayout - the layout of the source image subresources for the resolve
        dstImage - the destination image
        dstImageLayout - the layout of the destination image subresources for the resolve
      • vkCmdBeginQuery

        public static void vkCmdBeginQuery(VkCommandBuffer commandBuffer,
                                           long queryPool,
                                           int query,
                                           int flags)

        Khronos Reference Page

        Begins a query.

        Once queries are reset and ready for use, query commands can be issued to a command buffer. Occlusion queries and pipeline statistics queries count events - drawn samples and pipeline stage invocations, respectively - resulting from commands that are recorded between a vkCmdBeginQuery command and a CmdEndQuery command within a specified command buffer, effectively scoping a set of drawing and/or compute commands. Timestamp queries write timestamps to a query pool.

        A query must begin and end in the same command buffer, although if it is a primary command buffer, and the inherited queries feature is enabled, it can execute secondary command buffers during the query operation. For a secondary command buffer to be executed while a query is active, it must set the occlusionQueryEnable, queryFlags, and/or pipelineStatistics members of VkCommandBufferBeginInfo to conservative values. A query must either begin and end inside the same subpass of a render pass instance, or must both begin and end outside of a render pass instance (i.e. contain entire render pass instances).

        If the queryType of the pool is QUERY_TYPE_OCCLUSION and flags contains QUERY_CONTROL_PRECISE_BIT, an implementation must return a result that matches the actual number of samples passed.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • queryPool must be a valid VkQueryPool handle
        • flags must be a valid combination of VkQueryControlFlagBits values
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
        • Each of commandBuffer and queryPool must have been created, allocated or retrieved from the same VkDevice
        • The query identified by queryPool and query must currently not be active
        • The query identified by queryPool and query must be unavailable
        • If the precise occlusion queries feature is not enabled, or the queryType used to create queryPool was not QUERY_TYPE_OCCLUSION, flags must not contain QUERY_CONTROL_PRECISE_BIT
        • queryPool must have been created with a queryType that differs from that of any other queries that have been made active, and are currently still active within commandBuffer
        • query must be less than the number of queries in queryPool
        • If the queryType used to create queryPool was QUERY_TYPE_OCCLUSION, the VkCommandPool that commandBuffer was created from must support graphics operations
        • If the queryType used to create queryPool was QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate graphics operations, the VkCommandPool that commandBuffer was created from must support graphics operations
        • If the queryType used to create queryPool was QUERY_TYPE_PIPELINE_STATISTICS and any of the pipelineStatistics indicate compute operations, the VkCommandPool that commandBuffer was created from must support compute operations
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized

        After beginning a query, that query is considered active within the command buffer it was called in until that same query is ended. Queries active in a primary command buffer when secondary command buffers are executed are considered active for those secondary command buffers.

        Parameters:
        commandBuffer - the command buffer into which this command will be recorded
        queryPool - the query pool that will manage the results of the query
        query - the query index within the query pool that will contain the results
        flags - a bitmask indicating constraints on the types of queries that can be performed. One or more of:
        QUERY_CONTROL_PRECISE_BIT
      • vkCmdEndQuery

        public static void vkCmdEndQuery(VkCommandBuffer commandBuffer,
                                         long queryPool,
                                         int query)

        Khronos Reference Page

        Ends a query.
        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • queryPool must be a valid VkQueryPool handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
        • Each of commandBuffer and queryPool must have been created, allocated or retrieved from the same VkDevice
        • The query identified by queryPool and query must currently be active
        • query must be less than the number of queries in queryPool
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized

        As queries operate asynchronously, ending a query does not immediately set the query’s status to available. A query is considered finished when the final results of the query are ready to be retrieved by GetQueryPoolResults and CmdCopyQueryPoolResults, and this is when the query’s status is set to available.

        Once a query is ended the query must finish in finite time, unless the state of the query is changed using other commands, e.g. by issuing a reset of the query.

        An application can retrieve results either by requesting they be written into application-provided memory, or by requesting they be copied into a VkBuffer. In either case, the layout in memory is defined as follows:

        • The first query’s result is written starting at the first byte requested by the command, and each subsequent query’s result begins stride bytes later.
        • Each query’s result is a tightly packed array of unsigned integers, either 32- or 64-bits as requested by the command, storing the numerical results and, if requested, the availability status.
        • If QUERY_RESULT_WITH_AVAILABILITY_BIT is used, the final element of each query’s result is an integer indicating whether the query’s result is available, with any non-zero value indicating that it is available.
        • Occlusion queries write one integer value - the number of samples passed. Pipeline statistics queries write one integer value for each bit that is enabled in the pipelineStatistics when the pool is created, and the statistics values are written in bit order starting from the least significant bit. Timestamps write one integer value.
        • If more than one query is retrieved and stride is not at least as large as the size of the array of integers corresponding to a single query, the values written to memory are undefined.
        Parameters:
        commandBuffer - the command buffer into which this command will be recorded
        queryPool - the query pool that is managing the results of the query
        query - the query index within the query pool where the result is stored
      • vkCmdResetQueryPool

        public static void vkCmdResetQueryPool(VkCommandBuffer commandBuffer,
                                               long queryPool,
                                               int firstQuery,
                                               int queryCount)

        Khronos Reference Page

        Resets a range of queries in a query pool.

        When executed on a queue, this command sets the status of query indices firstQuery, firstQuery + queryCount − 1 to unavailable.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • queryPool must be a valid VkQueryPool handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
        • This command must only be called outside of a render pass instance
        • Each of commandBuffer and queryPool must have been created, allocated or retrieved from the same VkDevice
        • firstQuery must be less than the number of queries in queryPool
        • The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer into which this command will be recorded
        queryPool - the handle of the query pool managing the queries being reset
        firstQuery - the initial query index to reset
        queryCount - the number of queries to reset
      • vkCmdCopyQueryPoolResults

        public static void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,
                                                     long queryPool,
                                                     int firstQuery,
                                                     int queryCount,
                                                     long dstBuffer,
                                                     long dstOffset,
                                                     long stride,
                                                     int flags)

        Khronos Reference Page

        Copies query statuses and numerical results directly to buffer memory.

        vkCmdCopyQueryPoolResults is guaranteed to see the effect of previous uses of CmdResetQueryPool in the same queue, without any additional synchronization. Thus, the results will always reflect the most recent use of the query.

        flags has the same possible values described above for the flags parameter of GetQueryPoolResults, but the different style of execution causes some subtle behavioral differences. Because vkCmdCopyQueryPoolResults executes in order with respect to other query commands, there is less ambiguity about which use of a query is being requested.

        If no bits are set in flags, results for all requested queries in the available state are written as 32-bit unsigned integer values, and nothing is written for queries in the unavailable state.

        If QUERY_RESULT_64_BIT is set, the results are written as an array of 64-bit unsigned integer values as described for vkGetQueryPoolResults.

        If QUERY_RESULT_WAIT_BIT is set, the implementation will wait for each query’s status to be in the available state before retrieving the numerical results for that query. This is guaranteed to reflect the most recent use of the query on the same queue, assuming that the query is not being simultaneously used by other queues. If the query does not become available in a finite amount of time (e.g. due to not issuing a query since the last reset), a ERROR_DEVICE_LOST error may occur.

        Similarly, if QUERY_RESULT_WITH_AVAILABILITY_BIT is set and QUERY_RESULT_WAIT_BIT is not set, the availability is guaranteed to reflect the most recent use of the query on the same queue, assuming that the query is not being simultaneously used by other queues. As with vkGetQueryPoolResults, implementations must guarantee that if they return a non-zero availability value, then the numerical results are valid.

        If QUERY_RESULT_PARTIAL_BIT is set, QUERY_RESULT_WAIT_BIT is not set, and the query’s status is unavailable, an intermediate result value between zero and the final result value is written for that query.

        QUERY_RESULT_PARTIAL_BIT must not be used if the pool’s queryType is QUERY_TYPE_TIMESTAMP.

        vkCmdCopyQueryPoolResults is considered to be a transfer operation, and its writes to buffer memory must be synchronized using PIPELINE_STAGE_TRANSFER_BIT and ACCESS_TRANSFER_WRITE_BIT before using the results.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • queryPool must be a valid VkQueryPool handle
        • dstBuffer must be a valid VkBuffer handle
        • flags must be a valid combination of VkQueryResultFlagBits values
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
        • This command must only be called outside of a render pass instance
        • Each of commandBuffer, queryPool and dstBuffer must have been created, allocated or retrieved from the same VkDevice
        • dstOffset must be less than the size of dstBuffer
        • firstQuery must be less than the number of queries in queryPool
        • The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool
        • If QUERY_RESULT_64_BIT is not set in flags then dstOffset and stride must be multiples of 4
        • If QUERY_RESULT_64_BIT is set in flags then dstOffset and stride must be multiples of 8
        • dstBuffer must have enough storage, from dstOffset, to contain the result of each query, as described here
        • dstBuffer must have been created with BUFFER_USAGE_TRANSFER_DST_BIT usage flag
        • If the queryType used to create queryPool was QUERY_TYPE_TIMESTAMP, flags must not contain QUERY_RESULT_PARTIAL_BIT
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized

        Rendering operations such as clears, MSAA resolves, attachment load/store operations, and blits may count towards the results of queries. This behavior is implementation-dependent and may vary depending on the path used within an implementation. For example, some implementations have several types of clears, some of which may include vertices and some not.

        Parameters:
        commandBuffer - the command buffer into which this command will be recorded
        queryPool - the query pool managing the queries containing the desired results
        firstQuery - the initial query index
        queryCount - the number of queries. firstQuery and queryCount together define a range of queries
        dstBuffer - a VkBuffer object that will receive the results of the copy command
        dstOffset - an offset into dstBuffer
        stride - the stride in bytes between results for individual queries within dstBuffer
        flags - a bitmask of VkQueryResultFlagBits specifying how and when results are returned. One or more of:
        QUERY_RESULT_64_BITQUERY_RESULT_WAIT_BITQUERY_RESULT_WITH_AVAILABILITY_BIT
        QUERY_RESULT_PARTIAL_BIT
      • vkCmdPushConstants

        public static void vkCmdPushConstants(VkCommandBuffer commandBuffer,
                                              long layout,
                                              int stageFlags,
                                              int offset,
                                              java.nio.ByteBuffer pValues)

        Khronos Reference Page

        Updates the values of push constants.

        The pipeline layout defines shader push constants which are updated via Vulkan commands rather than via writes to memory or copy commands.

        Note

        Push constants represent a high speed path to modify constant data in pipelines that is expected to outperform memory-backed resource updates.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • layout must be a valid VkPipelineLayout handle
        • stageFlags must be a valid combination of VkShaderStageFlagBits values
        • stageFlags must not be 0
        • pValues must be a pointer to an array of size bytes
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics or compute operations
        • size must be greater than 0
        • Each of commandBuffer and layout must have been created, allocated or retrieved from the same VkDevice
        • stageFlags must match exactly the shader stages used in layout for the range specified by offset and size
        • offset must be a multiple of 4
        • size must be a multiple of 4
        • offset must be less than VkPhysicalDeviceLimits::maxPushConstantsSize
        • size must be less than or equal to VkPhysicalDeviceLimits::maxPushConstantsSize minus offset
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized
        Parameters:
        commandBuffer - the command buffer in which the push constant update will be recorded
        layout - the pipeline layout used to program the push constant updates
        stageFlags - a bitmask of VkShaderStageFlagBits specifying the shader stages that will use the push constants in the updated range. One or more of:
        SHADER_STAGE_VERTEX_BITSHADER_STAGE_TESSELLATION_CONTROL_BIT
        SHADER_STAGE_TESSELLATION_EVALUATION_BITSHADER_STAGE_GEOMETRY_BIT
        SHADER_STAGE_FRAGMENT_BITSHADER_STAGE_COMPUTE_BIT
        SHADER_STAGE_ALL_GRAPHICSSHADER_STAGE_ALL
        offset - the start offset of the push constant range to update, in units of bytes
        pValues - an array of size bytes containing the new push constant values
      • vkCmdNextSubpass

        public static void vkCmdNextSubpass(VkCommandBuffer commandBuffer,
                                            int contents)

        Khronos Reference Page

        Transitions to the next subpass of a render pass.
        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • contents must be a valid VkSubpassContents value
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called inside of a render pass instance
        • commandBuffer must be a primary VkCommandBuffer
        • The current subpass index must be less than the number of subpasses in the render pass minus one
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized

        The subpass index for a render pass begins at zero when CmdBeginRenderPass is recorded, and increments each time vkCmdNextSubpass is recorded.

        Moving to the next subpass automatically performs any multisample resolve operations in the subpass being ended. End-of-subpass multisample resolves are treated as color attachment writes for the purposes of synchronization. That is, they are considered to execute in the PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT pipeline stage and their writes are synchronized with ACCESS_COLOR_ATTACHMENT_WRITE_BIT. Synchronization between rendering within a subpass and any resolve operations at the end of the subpass occurs automatically, without need for explicit dependencies or pipeline barriers. However, if the resolve attachment is also used in a different subpass, an explicit dependency is needed.

        After transitioning to the next subpass, the application can record the commands for that subpass.

        Parameters:
        commandBuffer - the command buffer in which to record the command
        contents - specifies how the commands in the next subpass will be provided. One of:
        SUBPASS_CONTENTS_INLINESUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
      • vkCmdEndRenderPass

        public static void vkCmdEndRenderPass(VkCommandBuffer commandBuffer)

        Khronos Reference Page

        Ends a render pass instance.
        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support graphics operations
        • This command must only be called inside of a render pass instance
        • commandBuffer must be a primary VkCommandBuffer
        • The current subpass index must be equal to the number of subpasses in the render pass minus one
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized

        Ending a render pass instance performs any multisample resolve operations on the final subpass.

        Parameters:
        commandBuffer - the command buffer in which to end the current render pass instance
      • vkCmdExecuteCommands

        public static void vkCmdExecuteCommands(VkCommandBuffer commandBuffer,
                                                PointerBuffer pCommandBuffers)

        Khronos Reference Page

        Executes a secondary command buffer from a primary command buffer.

        A secondary command buffer must not be directly submitted to a queue. Instead, secondary command buffers are recorded to execute as part of a primary command buffer with this command.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • pCommandBuffers must be a pointer to an array of commandBufferCount valid VkCommandBuffer handles
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations
        • commandBuffer must be a primary VkCommandBuffer
        • commandBufferCount must be greater than 0
        • Each of commandBuffer and the elements of pCommandBuffers must have been created, allocated or retrieved from the same VkDevice
        • commandBuffer must have been created with a level of COMMAND_BUFFER_LEVEL_PRIMARY
        • Any given element of pCommandBuffers must have been created with a level of COMMAND_BUFFER_LEVEL_SECONDARY
        • Any given element of pCommandBuffers must not be already pending execution in commandBuffer, or appear twice in pCommandBuffers, unless it was created with the COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag
        • Any given element of pCommandBuffers must not be already pending execution in any other VkCommandBuffer, unless it was created with the COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag
        • Any given element of pCommandBuffers must be in the executable state
        • If CmdExecuteCommands is being called within a render pass instance, that render pass instance must have been begun with the contents parameter of CmdBeginRenderPass set to SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
        • If CmdExecuteCommands is being called within a render pass instance, any given element of pCommandBuffers must have been recorded with the COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
        • If CmdExecuteCommands is being called within a render pass instance, any given element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::subpass set to the index of the subpass which the given command buffer will be executed in
        • If CmdExecuteCommands is being called within a render pass instance, any given element of pCommandBuffers must have been recorded with a render pass that is compatible with the current render pass
        • If CmdExecuteCommands is being called within a render pass instance, and any given element of pCommandBuffers was recorded with VkCommandBufferInheritanceInfo::framebuffer not equal to NULL_HANDLE, that VkFramebuffer must be compatible with the VkFramebuffer used in the current render pass instance
        • If the inherited queries feature is not enabled, commandBuffer must not have any queries active
        • If commandBuffer has a QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::occlusionQueryEnable set to TRUE
        • If commandBuffer has a QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::queryFlags having all bits set that are set for the query
        • If commandBuffer has a QUERY_TYPE_PIPELINE_STATISTICS query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::pipelineStatistics having all bits set that are set in the VkQueryPool the query uses
        • Any given element of pCommandBuffers must not begin any query types that are active in commandBuffer
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized

        Once vkCmdExecuteCommands has been called, any prior executions of the secondary command buffers specified by pCommandBuffers in any other primary command buffer become invalidated, unless those secondary command buffers were recorded with COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT.

        Parameters:
        commandBuffer - a handle to a primary command buffer that the secondary command buffers are submitted to, and must be in the recording state
        pCommandBuffers - an array of secondary command buffer handles, which are recorded to execute in the primary command buffer in the order they are listed in the array
      • vkCmdExecuteCommands

        public static void vkCmdExecuteCommands(VkCommandBuffer commandBuffer,
                                                VkCommandBuffer pCommandBuffer)

        Khronos Reference Page

        Executes a secondary command buffer from a primary command buffer.

        A secondary command buffer must not be directly submitted to a queue. Instead, secondary command buffers are recorded to execute as part of a primary command buffer with this command.

        Valid Usage
        • commandBuffer must be a valid VkCommandBuffer handle
        • pCommandBuffers must be a pointer to an array of commandBufferCount valid VkCommandBuffer handles
        • commandBuffer must be in the recording state
        • The VkCommandPool that commandBuffer was allocated from must support transfer, graphics or compute operations
        • commandBuffer must be a primary VkCommandBuffer
        • commandBufferCount must be greater than 0
        • Each of commandBuffer and the elements of pCommandBuffers must have been created, allocated or retrieved from the same VkDevice
        • commandBuffer must have been created with a level of COMMAND_BUFFER_LEVEL_PRIMARY
        • Any given element of pCommandBuffers must have been created with a level of COMMAND_BUFFER_LEVEL_SECONDARY
        • Any given element of pCommandBuffers must not be already pending execution in commandBuffer, or appear twice in pCommandBuffers, unless it was created with the COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag
        • Any given element of pCommandBuffers must not be already pending execution in any other VkCommandBuffer, unless it was created with the COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag
        • Any given element of pCommandBuffers must be in the executable state
        • If CmdExecuteCommands is being called within a render pass instance, that render pass instance must have been begun with the contents parameter of CmdBeginRenderPass set to SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
        • If CmdExecuteCommands is being called within a render pass instance, any given element of pCommandBuffers must have been recorded with the COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
        • If CmdExecuteCommands is being called within a render pass instance, any given element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::subpass set to the index of the subpass which the given command buffer will be executed in
        • If CmdExecuteCommands is being called within a render pass instance, any given element of pCommandBuffers must have been recorded with a render pass that is compatible with the current render pass
        • If CmdExecuteCommands is being called within a render pass instance, and any given element of pCommandBuffers was recorded with VkCommandBufferInheritanceInfo::framebuffer not equal to NULL_HANDLE, that VkFramebuffer must be compatible with the VkFramebuffer used in the current render pass instance
        • If the inherited queries feature is not enabled, commandBuffer must not have any queries active
        • If commandBuffer has a QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::occlusionQueryEnable set to TRUE
        • If commandBuffer has a QUERY_TYPE_OCCLUSION query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::queryFlags having all bits set that are set for the query
        • If commandBuffer has a QUERY_TYPE_PIPELINE_STATISTICS query active, then each element of pCommandBuffers must have been recorded with VkCommandBufferInheritanceInfo::pipelineStatistics having all bits set that are set in the VkQueryPool the query uses
        • Any given element of pCommandBuffers must not begin any query types that are active in commandBuffer
        Host Synchronization
        • Host access to commandBuffer must be externally synchronized

        Once vkCmdExecuteCommands has been called, any prior executions of the secondary command buffers specified by pCommandBuffers in any other primary command buffer become invalidated, unless those secondary command buffers were recorded with COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT.

        Parameters:
        commandBuffer - a handle to a primary command buffer that the secondary command buffers are submitted to, and must be in the recording state